Class Component<C>

constructor

• new Component<C>(): Component<C>

• Type Parameters

  • C extends Component<C> = Component<any>

  Returns Component<C>

Readonly firstChild

Readonly key

Readonly lastChild

Readonly nextSibling

Optional Readonly observerType

Readonly parent

Readonly previousSibling

Static Readonly InsertChildFlags

Static Readonly MountFlags

Static Readonly ReinsertChildFlags

Static Readonly RemoveChildFlags

componentType

• get componentType(): Class<Component<Component<any>>>

• Returns Class<Component<Component<any>>>

insertChildFlags

• get insertChildFlags(): number

• Returns number

inserting

• get inserting(): boolean

• Returns boolean

mountFlags

• get mountFlags(): number

• Returns number

mounted

• get mounted(): boolean

• Returns boolean

reinsertChildFlags

• get reinsertChildFlags(): number

• Returns number

removeChildFlags

• get removeChildFlags(): number

• Returns number

removing

• get removing(): boolean

• Returns boolean

appendChild

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

• Type Parameters

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

  Parameters

  • childFactory: F

  • Optional key: string

  Returns InstanceType<F>

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

• Type Parameters

  • Child extends Component<C>

  Parameters

  • child: Child | LikeType<Child>

  • Optional key: string

  Returns Child

• appendChild(child, key?): C

• Parameters

  • child: C | LikeType<C>

  • Optional key: string

  Returns C

attachFastener

• attachFastener(fastener): void

• Parameters

  • fastener: Fastener<any, any, any>

  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

commonAncestor

• commonAncestor(relative): C

• Parameters

  • relative: C

  Returns C

decohereFastener

• decohereFastener(fastener): void

• Parameters

  • fastener: Fastener<any, any, any>

  Returns void

equals

• equals(that): boolean

• Parameters

  • that: unknown

  Returns boolean

forEachChild

• forEachChild<T>(callback): T

• Type Parameters

  • T

  Parameters

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

    • • (child): void | T

      • Parameters

        • child: C

        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: C

        Returns void | T

  • thisArg: S

  Returns T

getAncestor

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

• Type Parameters

  • F extends Class<C>

  Parameters

  • ancestorType: F

  Returns InstanceType<F>

• getAncestor(ancestorType): C

• Parameters

  • ancestorType: Class<C>

  Returns C

getChild

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

• Type Parameters

  • F extends Class<C>

  Parameters

  • key: string

  • childType: F

  Returns InstanceType<F>

• getChild(key, childType?): C

• Parameters

  • key: string

  • Optional childType: Class<C>

  Returns C

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

getFirstChild

• getFirstChild<F>(childType): InstanceType<F>

• Type Parameters

  • F extends Class<C>

  Parameters

  • childType: F

  Returns InstanceType<F>

• getFirstChild(childType): C

• Parameters

  • childType: Class<C>

  Returns C

getLastChild

• getLastChild<F>(childType): InstanceType<F>

• Type Parameters

  • F extends Class<C>

  Parameters

  • childType: F

  Returns InstanceType<F>

• getLastChild(childType): C

• Parameters

  • childType: Class<C>

  Returns C

getNextSibling

• getNextSibling<F>(siblingType): InstanceType<F>

• Type Parameters

  • F extends Class<C>

  Parameters

  • siblingType: F

  Returns InstanceType<F>

• getNextSibling(siblingType): C

• Parameters

  • siblingType: Class<C>

  Returns C

getParentFastener

• getParentFastener<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

getPreviousSibling

• getPreviousSibling<F>(siblingType): InstanceType<F>

• Type Parameters

  • F extends Class<C>

  Parameters

  • siblingType: F

  Returns InstanceType<F>

• getPreviousSibling(siblingType): C

• Parameters

  • siblingType: Class<C>

  Returns C

getRoot

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

• Type Parameters

  • F extends Class<C>

  Parameters

  • rootType: F

  Returns InstanceType<F>

• getRoot(rootType): C

• Parameters

  • rootType: Class<C>

  Returns C

getTargetChild

• getTargetChild(child, comparator): C

• Parameters

  • child: C

  • comparator: Comparator<C>

  Returns C

hashCode

• hashCode(): number

• Returns number

insertChild

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

• Type Parameters

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

  Parameters

  • childFactory: F

  • target: C

  • Optional key: string

  Returns InstanceType<F>

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

• Type Parameters

  • Child extends Component<C>

  Parameters

  • child: Child | LikeType<Child>

  • target: C

  • Optional key: string

  Returns Child

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

• Parameters

  • child: C | LikeType<C>

  • target: C

  • Optional key: string

  Returns C

isAncestorOf

• isAncestorOf(descendant): boolean

• Parameters

  • descendant: C

  Returns boolean

Optional likeType

• likeType(like): void

• Parameters

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

    • create?:function

      • create(): C

      • Returns C

  Returns void

mount

• mount(): void

• Returns void

observe

• observe(observer): void

• Parameters

  • observer: ComponentObserver<Component<Component<any>>>

  Returns void

prependChild

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

• Type Parameters

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

  Parameters

  • childFactory: F

  • Optional key: string

  Returns InstanceType<F>

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

• Type Parameters

  • Child extends Component<C>

  Parameters

  • child: Child | LikeType<Child>

  • Optional key: string

  Returns Child

• prependChild(child, key?): C

• Parameters

  • child: C | LikeType<C>

  • Optional key: string

  Returns C

recohereFasteners

• recohereFasteners(t?): void

• Parameters

  • Optional t: number

  Returns void

reinsertChild

• reinsertChild(child, target): void

• Parameters

  • child: C

  • target: C

  Returns void

remove

• remove(): void

• Returns void

removeChild

• removeChild<Child>(child): Child

• Type Parameters

  • Child extends Component<C>

  Parameters

  • child: Child

  Returns Child

• removeChild(child): C

• Parameters

  • child: C

  Returns C

• removeChild(key): C

• Parameters

  • key: string | C

  Returns C

removeChildren

• removeChildren(): void

• Returns void

replaceChild

• replaceChild<F>(newChildFactory, oldChild): C

• Type Parameters

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

  Parameters

  • newChildFactory: F

  • oldChild: C

  Returns C

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

• Type Parameters

  • Child extends Component<C>

  Parameters

  • newChild: C | LikeType<C>

  • oldChild: Child

  Returns Child

• replaceChild(newChild, oldChild): C

• Parameters

  • newChild: C | LikeType<C>

  • oldChild: C

  Returns C

requireUpdate

• requireUpdate(updateFlags, immediate?): void

• Parameters

  • updateFlags: number

  • Optional immediate: boolean

  Returns void

set

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

• 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 Component<C>

setChild

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

• Type Parameters

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

  Parameters

  • key: string

  • newChildFactory: F

  Returns C

• setChild(key, newChild): C

• Parameters

  • key: string

  • newChild: C | LikeType<C>

  Returns C

setIntrinsic

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

• 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 Component<C>

sortChildren

• sortChildren(comparator): void

• Parameters

  • comparator: Comparator<C>

  Returns void

tryFastener

• tryFastener<K, F>(fastenerName): F extends Fastener<any, any, any>
      ? F
      : never

• Type Parameters

  • K extends keyof Component<C>

  • F extends string | number | boolean | readonly Fastener<any, any, any>[] | Component<C> | ((like) => void) | Class<ComponentObserver<Component<Component<any>>>> | Class<Component<Component<any>>> | {} | {} | {} | {} | {} | {
        <F>(siblingType): InstanceType<F>;
        (siblingType): C;
    } | {} | {
        <F>(siblingType): InstanceType<F>;
        (siblingType): C;
    } | {} | {
        <F>(childType): InstanceType<F>;
        (childType): C;
    } | {} | {
        <F>(childType): InstanceType<F>;
        (childType): C;
    } | {} | {
        <T>(callback): T;
        <T, S>(callback, thisArg): T;
    } | Dictionary<C> | {
        <F>(key, childType): InstanceType<F>;
        (key, childType?): C;
    } | {
        <F>(key, newChildFactory): C;
        (key, newChild): C;
    } | {
        <F>(childFactory, key?): InstanceType<F>;
        <Child>(child, key?): Child;
        (child, key?): C;
    } | {
        <F>(childFactory, key?): InstanceType<F>;
        <Child>(child, key?): Child;
        (child, key?): C;
    } | {
        <F>(childFactory, target, key?): InstanceType<F>;
        <Child>(child, target, key?): Child;
        (child, target, key?): C;
    } | {
        <F>(newChildFactory, oldChild): C;
        <Child>(newChild, oldChild): Child;
        (newChild, oldChild): C;
    } | {} | {
        <Child>(child): Child;
        (child): C;
        (key): C;
    } | (() => void) | (() => void) | ((child, target) => void) | ((comparator) => void) | ((child, comparator) => C) | {
        <F>(ancestorType): InstanceType<F>;
        (ancestorType): C;
    } | {
        <F>(rootType): InstanceType<F>;
        (rootType): C;
    } | ((descendant) => boolean) | ((relative) => C) | (() => void) | {} | (() => void) | {} | ((updateFlags, immediate?) => void) | (<F>(fastenerName, fastenerType?, contextType?) => F) | (<F>(fastenerName, fastenerType?, contextType?) => F) | ((fastener) => void) | ((fastener) => void) | ((t?) => void) | ReadonlySet<ComponentObserver<Component<Component<any>>>> | (<O, K>(this, key, ...args) => void) | ((that) => boolean) | (() => number) | (<K, F>(fastenerName) => F extends Fastener<any, any, any>
        ? F
        : never) | (<S>(this, properties, timing?) => Component<C>) | (<S>(this, properties, timing?) => Component<C>) | ((observer) => void) | ((observer) => void) = Component<C>[K]

  Parameters

  • fastenerName: K

  Returns F extends Fastener<any, any, any>
      ? F
      : never

unmount

• unmount(): void

• Returns void

unobserve

• unobserve(observer): void

• Parameters

  • observer: ComponentObserver<Component<Component<any>>>

  Returns void

Static create

• create<S>(this): InstanceType<S>

• Type Parameters

  • S extends (new () => InstanceType<S>)

  Parameters

  • this: S

  Returns InstanceType<S>

Static fromLike

• fromLike<S>(this, value): InstanceType<S>

• Type Parameters

  • S extends Class<Instance<S, Component<Component<any>>>>

  Parameters

  • this: S

  • value: InstanceType<S> | LikeType<InstanceType<S>>

  Returns InstanceType<S>