Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Model

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

Readonly Abstract childModelCount

childModelCount: number

Readonly Abstract childModels

childModels: readonly Model[]

Readonly Abstract key

key: undefined | string

Readonly Abstract modelConsumers

modelConsumers: readonly unknown[]

Readonly modelFlags

modelFlags: number

Readonly modelObservers

modelObservers: readonly ModelObserver<Model>[]

Readonly Abstract parentModel

parentModel: null | Model

Readonly refreshService

refreshService: RefreshService<Model>

Readonly traits

traits: readonly Trait[]

Readonly warpRef

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

Readonly warpService

warpService: WarpService<Model>

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

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

Abstract addModelConsumer

  • addModelConsumer(modelConsumer: unknown): void

addModelObserver

Protected Abstract analyzeChildModels

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

Abstract appendChildModel

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

appendTrait

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

Protected attachParentModel

  • attachParentModel(parentModel: Model): void

Abstract cascadeAnalyze

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

Abstract cascadeInsert

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

Abstract cascadeMount

  • cascadeMount(): void

Abstract cascadePower

  • cascadePower(): void

Abstract cascadeRefresh

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

Abstract cascadeUnmount

  • cascadeUnmount(): void

Abstract cascadeUnpower

  • cascadeUnpower(): 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 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

Abstract firstChildModel

  • firstChildModel(): null | Model

firstTrait

  • firstTrait(): null | Trait

Abstract forEachChildModel

  • forEachChildModel<T>(callback: (childModel: Model) => void | T): undefined | T
  • forEachChildModel<T, S>(callback: (childModel: Model) => void | T, thisArg: S): 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

Abstract getChildModel

  • getChildModel(key: string): null | Model

Abstract getModelDownlink

Abstract getModelFastener

Abstract getModelProperty

Abstract getModelService

Abstract getModelTrait

getSuperModel

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

getSuperTrait

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

getTrait

Abstract hasModelDownlink

  • hasModelDownlink(downlinkName: string): boolean

Abstract hasModelFastener

  • hasModelFastener(fastenerName: string): boolean

Abstract hasModelProperty

  • hasModelProperty(propertyName: string): boolean

Abstract hasModelService

  • hasModelService(serviceName: string): boolean

Abstract hasModelTrait

  • hasModelTrait(fastenerName: string): boolean

initModel

Abstract insertChildModel

  • insertChildModel(childModel: Model, targetModel: null | Model, key?: string): 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

Abstract lastChildModel

  • lastChildModel(): null | Model

lastTrait

  • lastTrait(): null | Trait

mount

  • mount(): void

needsAnalyze

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

needsRefresh

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

Abstract 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

Protected onInsertTrait

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

Protected onMount

  • onMount(): void

Protected onMutate

Protected onPower

  • onPower(): void

Protected onReconcile

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

Protected onRemoveModelConsumer

  • onRemoveModelConsumer(modelConsumer: unknown): void

Protected onRemoveModelObserver

Protected onRemoveTrait

  • onRemoveTrait(oldTrait: Trait): 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

Protected onStopConsuming

  • onStopConsuming(): void

Protected onUnmount

  • onUnmount(): void

Protected onUnpower

  • onUnpower(): void

Protected onValidate

Abstract prependChildModel

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

prependTrait

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

Abstract previousChildModel

  • previousChildModel(targetModel: Model): null | Model

previousTrait

Protected Abstract refreshChildModels

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

Abstract remove

  • remove(): void

Abstract removeAll

  • removeAll(): void

Abstract removeChildModel

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

Abstract removeModelConsumer

  • removeModelConsumer(modelConsumer: unknown): void

removeModelObserver

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

Abstract setChildModel

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

Abstract setModelDownlink

  • setModelDownlink(downlinkName: string, modelDownlink: null | ModelDownlink<Model>): void

Abstract setModelFastener

  • setModelFastener(fastenerName: string, modelFastener: null | ModelFastener<Model, any, never>): void

setModelFlags

  • setModelFlags(modelFlags: number): void

Abstract setModelProperty

  • setModelProperty(propertyName: string, modelProperty: null | ModelProperty<Model, unknown, never>): void

Abstract setModelService

  • setModelService(serviceName: string, modelService: null | ModelService<Model, unknown>): void

Abstract setModelTrait

  • setModelTrait(fastenerName: string, modelTrait: null | ModelTrait<Model, any, never>): void

setTrait

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

Protected startConsuming

  • startConsuming(): void

Protected stopConsuming

  • stopConsuming(): 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 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