Options
All
  • Public
  • Public/Protected
  • All
Menu

Class CompoundModel

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

Readonly childModelMap

childModelMap: null | {}

Readonly childModels

childModels: readonly Model[]

Readonly key

key: undefined | string

Readonly modelConsumers

modelConsumers: readonly unknown[]

Readonly modelDownlinks

modelDownlinks: null | {}

Readonly modelFasteners

modelFasteners: null | {}

Readonly modelFlags

modelFlags: number

Readonly modelObservers

modelObservers: readonly ModelObserver<Model>[]

Readonly modelProperties

modelProperties: null | {}

Readonly modelServices

modelServices: null | {}

Readonly modelTraits

modelTraits: null | {}

Readonly parentModel

parentModel: null | Model

Readonly refreshService

refreshService: RefreshService<CompoundModel>

Readonly traits

traits: readonly Trait[]

Readonly warpRef

warpRef: ModelProperty<CompoundModel, null | WarpRef, never>

Readonly warpService

warpService: WarpService<CompoundModel>

Static Readonly Extrinsic

Extrinsic: number = 1

Static Readonly Intrinsic

Intrinsic: number = 0

Static Readonly NeedsAggregate

NeedsAggregate: number = ...

Static Readonly NeedsAnalyze

NeedsAnalyze: number = ...

Static Readonly NeedsCorrelate

NeedsCorrelate: number = ...

Static Readonly NeedsMutate

NeedsMutate: number = ...

Static Readonly NeedsReconcile

NeedsReconcile: number = ...

Static Readonly NeedsRefresh

NeedsRefresh: number = ...

Static Readonly NeedsValidate

NeedsValidate: number = ...

Static Readonly insertChildFlags

insertChildFlags: number = 0

Static Readonly insertTraitFlags

insertTraitFlags: number = 0

Static Readonly mountFlags

mountFlags: number = 0

Static Readonly powerFlags

powerFlags: number = 0

Static Readonly removeChildFlags

removeChildFlags: number = 0

Static Readonly removeTraitFlags

removeTraitFlags: number = 0

Static Readonly startConsumingFlags

startConsumingFlags: number = 0

Static Readonly stopConsumingFlags

stopConsumingFlags: number = 0

Accessors

childModelCount

  • get childModelCount(): number

  • Returns number

insertChildFlags

  • get insertChildFlags(): number

insertTraitFlags

  • get insertTraitFlags(): number

modelContext

mountFlags

  • get mountFlags(): number

powerFlags

  • get powerFlags(): number

removeChildFlags

  • get removeChildFlags(): number

removeTraitFlags

  • get removeTraitFlags(): number

startConsumingFlags

  • get startConsumingFlags(): number

stopConsumingFlags

  • get stopConsumingFlags(): number

superModelContext

traitCount

  • get traitCount(): number

Methods

addModelConsumer

  • addModelConsumer(modelConsumer: unknown): void

  • Parameters

    • modelConsumer: unknown

    Returns void

addModelObserver

Protected analyzeChildModels

  • analyzeChildModels(analyzeFlags: number, modelContext: ModelContext, analyzeChildModel: (childModel: Model, analyzeFlags: number, modelContext: ModelContext) => void): void

  • Parameters

    Returns void

Protected analyzeOwnChildModels

  • analyzeOwnChildModels(analyzeFlags: number, modelContext: ModelContext, analyzeChildModel: (childModel: Model, analyzeFlags: number, modelContext: ModelContext) => void): void

Protected analyzeTraitChildModels

  • analyzeTraitChildModels(traits: readonly Trait[], traitIndex: number, analyzeFlags: number, modelContext: ModelContext, analyzeChildModel: (childModel: Model, analyzeFlags: number, modelContext: ModelContext) => void): void

  • Parameters

    • traits: readonly Trait[]
    • traitIndex: number
    • analyzeFlags: number
    • modelContext: ModelContext
    • analyzeChildModel: (childModel: Model, analyzeFlags: number, modelContext: ModelContext) => void

    Returns void

appendChildModel

  • appendChildModel(childModel: Model, key?: string): void

  • Parameters

    • childModel: Model
    • Optional key: string

    Returns void

appendTrait

  • appendTrait(trait: Trait, key?: string): void

Protected attachParentModel

  • attachParentModel(parentModel: Model): void

cascadeAnalyze

  • cascadeAnalyze(analyzeFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

cascadeInsert

  • cascadeInsert(updateFlags?: number, modelContext?: ModelContext): void

  • Parameters

    • Optional updateFlags: number
    • Optional modelContext: ModelContext

    Returns void

cascadeMount

  • cascadeMount(): void

  • Returns void

cascadePower

  • cascadePower(): void

  • Returns void

cascadeRefresh

  • cascadeRefresh(refreshFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

cascadeUnmount

  • cascadeUnmount(): void

  • Returns void

cascadeUnpower

  • cascadeUnpower(): void

  • Returns void

Protected detachParentModel

  • detachParentModel(parentModel: Model): void

Protected didAddModelConsumer

  • didAddModelConsumer(modelConsumer: unknown): void

Protected didAddModelObserver

Protected didAggregate

Protected didAnalyze

  • didAnalyze(analyzeFlags: number, modelContext: ModelContext): void

Protected didAnalyzeChildModel

  • didAnalyzeChildModel(childModel: Model, analyzeFlags: number, modelContext: ModelContext): void

Protected didAnalyzeChildModels

  • didAnalyzeChildModels(analyzeFlags: number, modelContext: ModelContext): void

Protected didCorrelate

Protected didInsertChildModel

  • didInsertChildModel(childModel: Model, targetModel: null | Model): void

Protected didInsertTrait

  • didInsertTrait(newTrait: Trait, targetTrait: null | Trait): void

Protected didMount

  • didMount(): void

Protected didMutate

Protected didObserve

  • didObserve<T>(callback: (modelObserver: ModelObserver<Model>) => void | T): undefined | T

Protected didPower

  • didPower(): void

Protected didReconcile

Protected didRefresh

  • didRefresh(refreshFlags: number, modelContext: ModelContext): void

Protected didRefreshChildModel

  • didRefreshChildModel(childModel: Model, refreshFlags: number, modelContext: ModelContext): void

Protected didRefreshChildModels

  • didRefreshChildModels(refreshFlags: number, modelContext: ModelContext): void

Protected didRemoveChildModel

  • didRemoveChildModel(childModel: Model): void

Protected didRemoveModelConsumer

  • didRemoveModelConsumer(modelConsumer: unknown): void

Protected didRemoveModelObserver

Protected didRemoveTrait

  • didRemoveTrait(oldTrait: Trait): void

Protected didRequestUpdate

  • didRequestUpdate(targetModel: Model, updateFlags: number, immediate: boolean): void

Protected didRequireUpdate

  • didRequireUpdate(updateFlags: number, immediate: boolean): void

Protected didSetParentModel

  • didSetParentModel(newParentModel: null | Model, oldParentModel: null | Model): void

Protected didStartConsuming

  • didStartConsuming(): void

Protected didStopConsuming

  • didStopConsuming(): void

Protected didUnmount

  • didUnmount(): void

Protected didUnpower

  • didUnpower(): void

Protected didValidate

Protected doAnalyze

  • doAnalyze(analyzeFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

Protected doMountChildModels

  • doMountChildModels(): void

Protected doMountTraits

  • doMountTraits(): void

  • Returns void

Protected doPowerChildModels

  • doPowerChildModels(): void

Protected doPowerTraits

  • doPowerTraits(): void

  • Returns void

Protected doRefresh

  • doRefresh(refreshFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

Protected doUnmountChildModels

  • doUnmountChildModels(): void

Protected doUnmountTraits

  • doUnmountTraits(): void

  • Returns void

Protected doUnpowerChildModels

  • doUnpowerChildModels(): void

Protected doUnpowerTraits

  • doUnpowerTraits(): void

  • Returns void

firstChildModel

  • firstChildModel(): null | Model

firstTrait

  • firstTrait(): null | Trait

forEachChildModel

  • forEachChildModel<T>(callback: (childModel: Model) => void | T): undefined | T
  • forEachChildModel<T, S>(callback: (childModel: Model) => void | T, thisArg: S): undefined | T

  • Type parameters

    • T

    Parameters

    • callback: (childModel: Model) => void | T
        • (childModel: Model): void | T

        • Parameters

          Returns void | T

    Returns undefined | T

  • Type parameters

    • T

    • S

    Parameters

    • callback: (childModel: Model) => void | T
        • (childModel: Model): void | T

        • Parameters

          Returns void | T

    • thisArg: S

    Returns undefined | T

forEachTrait

  • forEachTrait<T>(callback: (trait: Trait) => void | T): undefined | T
  • forEachTrait<T, S>(callback: (trait: Trait) => void | T, thisArg: S): undefined | T

getBaseModel

  • getBaseModel<M>(modelClass: ModelClass<M>): null | M

getBaseTrait

  • getBaseTrait<R>(traitClass: TraitClass<R>): null | R

getChildModel

  • getChildModel(key: string): null | Model

  • Parameters

    • key: string

    Returns null | Model

getModelDownlink

getModelFastener

getModelProperty

getModelService

getModelTrait

getSuperModel

  • getSuperModel<M>(modelClass: ModelClass<M>): null | M

getSuperTrait

  • getSuperTrait<R>(traitClass: TraitClass<R>): null | R

getTrait

hasModelDownlink

  • hasModelDownlink(downlinkName: string): boolean

  • Parameters

    • downlinkName: string

    Returns boolean

hasModelFastener

  • hasModelFastener(fastenerName: string): boolean

  • Parameters

    • fastenerName: string

    Returns boolean

hasModelProperty

  • hasModelProperty(propertyName: string): boolean

  • Parameters

    • propertyName: string

    Returns boolean

hasModelService

  • hasModelService(serviceName: string): boolean

  • Parameters

    • serviceName: string

    Returns boolean

hasModelTrait

  • hasModelTrait(fastenerName: string): boolean

  • Parameters

    • fastenerName: string

    Returns boolean

initModel

insertChildModel

  • insertChildModel(childModel: Model, targetModel: null | Model, key?: string): void

  • Parameters

    • childModel: Model
    • targetModel: null | Model
    • Optional key: string

    Returns void

Protected insertChildModelMap

  • insertChildModelMap(childModel: Model): void

  • Parameters

    Returns void

Protected insertModelFastener

  • insertModelFastener(childModel: Model, targetModel: null | Model): void

  • Parameters

    Returns void

Protected insertModelTrait

  • insertModelTrait(trait: Trait, targetTrait: null | Trait): void

  • Parameters

    Returns void

insertTrait

  • insertTrait(trait: Trait, targetTrait: null | Trait, key?: string): void

isAnalyzing

  • isAnalyzing(): boolean

isConsuming

  • isConsuming(): boolean

isMounted

  • isMounted(): boolean

isPowered

  • isPowered(): boolean

isRefreshing

  • isRefreshing(): boolean

isTraversing

  • isTraversing(): boolean

isUpdating

  • isUpdating(): boolean

lastChildModel

  • lastChildModel(): null | Model

lastTrait

  • lastTrait(): null | Trait

mount

  • mount(): void

Protected mountModelDownlinks

  • mountModelDownlinks(): void

Protected mountModelFasteners

  • mountModelFasteners(): void

Protected mountModelProperties

  • mountModelProperties(): void

Protected mountModelServices

  • mountModelServices(): void

Protected mountModelTraits

  • mountModelTraits(): void

  • Returns void

mutateModelProperties

  • mutateModelProperties(): void

needsAnalyze

  • needsAnalyze(analyzeFlags: number, modelContext: ModelContext): number

needsRefresh

  • needsRefresh(refreshFlags: number, modelContext: ModelContext): number

nextChildModel

  • nextChildModel(targetModel: Model): null | Model

nextTrait

Protected onAddModelConsumer

  • onAddModelConsumer(modelConsumer: unknown): void

Protected onAddModelObserver

Protected onAggregate

Protected onAnalyze

  • onAnalyze(analyzeFlags: number, modelContext: ModelContext): void

Protected onAnalyzeChildModel

  • onAnalyzeChildModel(childModel: Model, analyzeFlags: number, modelContext: ModelContext): void

Protected onAnalyzeChildModels

  • onAnalyzeChildModels(analyzeFlags: number, modelContext: ModelContext): void

Protected onCorrelate

Protected onInsertChildModel

  • onInsertChildModel(childModel: Model, targetModel: null | Model): void

  • Parameters

    Returns void

Protected onInsertTrait

  • onInsertTrait(trait: Trait, targetTrait: null | Trait): void

  • Parameters

    Returns void

Protected onMount

  • onMount(): void

  • Returns void

Protected onMutate

  • Parameters

    Returns void

Protected onPower

  • onPower(): void

Protected onReconcile

  • Parameters

    Returns void

Protected onRefresh

  • onRefresh(refreshFlags: number, modelContext: ModelContext): void

Protected onRefreshChildModel

  • onRefreshChildModel(childModel: Model, refreshFlags: number, modelContext: ModelContext): void

Protected onRefreshChildModels

  • onRefreshChildModels(refreshFlags: number, modelContext: ModelContext): void

Protected onRemoveChildModel

  • onRemoveChildModel(childModel: Model): void

  • Parameters

    Returns void

Protected onRemoveModelConsumer

  • onRemoveModelConsumer(modelConsumer: unknown): void

Protected onRemoveModelObserver

Protected onRemoveTrait

  • onRemoveTrait(trait: Trait): void

  • Parameters

    Returns void

Protected onRequestUpdate

  • onRequestUpdate(targetModel: Model, updateFlags: number, immediate: boolean): void

Protected onRequireUpdate

  • onRequireUpdate(updateFlags: number, immediate: boolean): void

Protected onSetParentModel

  • onSetParentModel(newParentModel: null | Model, oldParentModel: null | Model): void

Protected onStartConsuming

  • onStartConsuming(): void

  • Returns void

Protected onStopConsuming

  • onStopConsuming(): void

  • Returns void

Protected onUnmount

  • onUnmount(): void

  • Returns void

Protected onUnpower

  • onUnpower(): void

Protected onValidate

prependChildModel

  • prependChildModel(childModel: Model, key?: string): void

  • Parameters

    • childModel: Model
    • Optional key: string

    Returns void

prependTrait

  • prependTrait(trait: Trait, key?: string): void

previousChildModel

  • previousChildModel(targetModel: Model): null | Model

previousTrait

Protected reconcileModelDownlinks

  • reconcileModelDownlinks(): void

Protected refreshChildModels

  • refreshChildModels(refreshFlags: number, modelContext: ModelContext, refreshChildModel: (childModel: Model, refreshFlags: number, modelContext: ModelContext) => void): void

  • Parameters

    Returns void

Protected refreshOwnChildModels

  • refreshOwnChildModels(refreshFlags: number, modelContext: ModelContext, refreshChildModel: (childModel: Model, refreshFlags: number, modelContext: ModelContext) => void): void

Protected refreshTraitChildModels

  • refreshTraitChildModels(traits: readonly Trait[], traitIndex: number, refreshFlags: number, modelContext: ModelContext, refreshChildModel: (childModel: Model, refreshFlags: number, modelContext: ModelContext) => void): void

  • Parameters

    • traits: readonly Trait[]
    • traitIndex: number
    • refreshFlags: number
    • modelContext: ModelContext
    • refreshChildModel: (childModel: Model, refreshFlags: number, modelContext: ModelContext) => void

    Returns void

remove

  • remove(): void

  • Returns void

removeAll

  • removeAll(): void

  • Returns void

removeChildModel

  • removeChildModel(key: string): null | Model
  • removeChildModel(childModel: Model): void

  • Parameters

    • key: string

    Returns null | Model

  • Parameters

    Returns void

Protected removeChildModelMap

  • removeChildModelMap(childModel: Model): void

  • Parameters

    Returns void

removeModelConsumer

  • removeModelConsumer(modelConsumer: unknown): void

  • Parameters

    • modelConsumer: unknown

    Returns void

Protected removeModelFastener

  • removeModelFastener(childModel: Model): void

removeModelObserver

Protected removeModelTrait

  • removeModelTrait(trait: Trait): void

  • Parameters

    Returns void

removeTrait

  • removeTrait(key: string): null | Trait
  • removeTrait(trait: Trait): void

requestUpdate

  • requestUpdate(targetModel: Model, updateFlags: number, immediate: boolean): void

requireUpdate

  • requireUpdate(updateFlags: number, immediate?: boolean): void

setChildModel

  • setChildModel(key: string, newChildModel: null | Model): null | Model

  • Parameters

    • key: string
    • newChildModel: null | Model

    Returns null | Model

setKey

  • setKey(key: undefined | string): void

  • Parameters

    • key: undefined | string

    Returns void

setModelDownlink

setModelFastener

setModelFlags

  • setModelFlags(modelFlags: number): void

setModelProperty

setModelService

setModelTrait

setParentModel

  • setParentModel(newParentModel: null | Model, oldParentModel: null | Model): void

  • Parameters

    • newParentModel: null | Model
    • oldParentModel: null | Model

    Returns void

setTrait

  • setTrait(key: string, newTrait: null | Trait): null | Trait

Protected startConsuming

  • startConsuming(): void

Protected startConsumingModelDownlinks

  • startConsumingModelDownlinks(): void

Protected stopConsuming

  • stopConsuming(): void

Protected stopConsumingModelDownlinks

  • stopConsumingModelDownlinks(): void

Protected unmountModelDownlinks

  • unmountModelDownlinks(): void

Protected unmountModelFasteners

  • unmountModelFasteners(): void

Protected unmountModelProperties

  • unmountModelProperties(): void

Protected unmountModelServices

  • unmountModelServices(): void

Protected unmountModelTraits

  • unmountModelTraits(): void

  • Returns void

Protected willAddModelConsumer

  • willAddModelConsumer(modelConsumer: unknown): void

Protected willAddModelObserver

Protected willAggregate

Protected willAnalyze

  • willAnalyze(analyzeFlags: number, modelContext: ModelContext): void

Protected willAnalyzeChildModel

  • willAnalyzeChildModel(childModel: Model, analyzeFlags: number, modelContext: ModelContext): void

Protected willAnalyzeChildModels

  • willAnalyzeChildModels(analyzeFlags: number, modelContext: ModelContext): void

Protected willCorrelate

Protected willInsertChildModel

  • willInsertChildModel(childModel: Model, targetModel: null | Model): void

Protected willInsertTrait

  • willInsertTrait(newTrait: Trait, targetTrait: null | Trait): void

Protected willMount

  • willMount(): void

Protected willMutate

Protected willObserve

  • willObserve<T>(callback: (modelObserver: ModelObserver<Model>) => void | T): undefined | T

Protected willPower

  • willPower(): void

Protected willReconcile

Protected willRefresh

  • willRefresh(refreshFlags: number, modelContext: ModelContext): void

Protected willRefreshChildModel

  • willRefreshChildModel(childModel: Model, refreshFlags: number, modelContext: ModelContext): void

Protected willRefreshChildModels

  • willRefreshChildModels(refreshFlags: number, modelContext: ModelContext): void

Protected willRemoveChildModel

  • willRemoveChildModel(childModel: Model): void

Protected willRemoveModelConsumer

  • willRemoveModelConsumer(modelConsumer: unknown): void

Protected willRemoveModelObserver

Protected willRemoveTrait

  • willRemoveTrait(oldTrait: Trait): void

Protected willRequestUpdate

  • willRequestUpdate(targetModel: Model, updateFlags: number, immediate: boolean): void

Protected willRequireUpdate

  • willRequireUpdate(updateFlags: number, immediate: boolean): void

Protected willSetParentModel

  • willSetParentModel(newParentModel: null | Model, oldParentModel: null | Model): void

Protected willStartConsuming

  • willStartConsuming(): void

Protected willStopConsuming

  • willStopConsuming(): void

Protected willUnmount

  • willUnmount(): void

Protected willUnpower

  • willUnpower(): void

Protected willValidate

Generated using TypeDoc