A Behavior with specialization for a specific cluster.

To implement cluster functionality you should use a subclass provided by ClusterBehavior.for with the ClusterType you are implementing. Most commonly you would use one of the predefined implementations matter.js includes.

Subclasses can be modified using the static builder methods or extended like a normal class.

Behaviors should store all mutable state in their Behavior.state property. Other fields will be transient and may not be retained across invocations.

ClusterBehaviors may be instantiated with unsupported mandatory commands and attributes. This is currently results in a runtime error but it will not cause a type error during development.

Hierarchy (view full)

Constructors

Properties

events: EventEmitter

Access the behavior's events.

state: {}

Access the behavior's state.

cluster: Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}> = ClusterType.Unknown

Every cluster behavior has an associated ClusterType defined statically.

dependencies: typeof NetworkBehavior[] = ...

Keep networking alive until I'm destroyed.

early = true

All ClusterBehavior initialization currently runs as part of Endpoint initialization.

id: Uncapitalize<string>

The ID of ClusterBehavior implementations is the uncapitalized cluster name.

Interface: {
    components: never[];
} = ClusterInterface.Empty

Method definitions.

Internal: (new () => {}) = EmptyState

Implementation of internal state. Subclasses may override to extend.

schema?: Schema

A behavior's schema controls access to data, commands and events.

Schema is inferred from the methods and properties of the behavior but you can specify explicitly for additional control.

State: (new () => {}) = EmptyState

Implementation of endpoint-scoped state. Subclasses may override to extend.

Accessors

  • get cluster(): Of<{
        attributes: {};
        commands: {};
        events: {};
        id: 0;
        name: "Unknown";
        revision: 0;
    }>
  • The cluster implemented by this behavior.

    Returns Of<{
        attributes: {};
        commands: {};
        events: {};
        id: 0;
        name: "Unknown";
        revision: 0;
    }>

Methods

  • Execute logic with elevated privileges.

    The provided function executes with privileges escalated to offline mode. This is not commonly necessary.

    Elevated logic effectively ignores ACLs so should be used with care.

    Note that interactions with the behavior will remain elevated until the synchronous completion of this call. You should only elevate privileges for synchronous logic.

    Parameters

    • fn: (() => void)

      the elevated logic

        • (): void
        • Returns void

    Returns void

  • Create a generic callback function that has the same properties as a Reactor.

    Like a reactor, the callback's "this" will be bound to an active Behavior instance. Because of this: The reactor MUST be a real JS function - arrow functions will not work!

    Type Parameters

    • A extends any[]
    • R

    Parameters

    Returns ((...args: A) => undefined | R)

      • (...args): undefined | R
      • Parameters

        • Rest...args: A

        Returns undefined | R

  • Behaviors are ephemeral and should not perform initialization in their constructor. They can override this method instead.

    This method may be synchronous or asyncronous. If asynchronous, the behavior will not be available for external use until initialization completes.

    Parameters

    • Optional_options: {}

      Returns MaybePromise

    • Create a ClusterBehavior like this one with different interface methods.

      The Interface "property" is type-only. We define a method however to keep the API consistent. At runtime the method is a no-op.

      Type Parameters

      Returns Type<Of<{
          attributes: {};
          commands: {};
          events: {};
          id: 0;
          name: "Unknown";
          revision: 0;
      }>, typeof ClusterBehavior, I>