All Classes and Interfaces
Class
Description
Abstract base class for repositories that contain Arez components.
Annotation added to a class or interface that indicates that the type should be treated as
a component when verifying references to type.
Methods marked with this annotation are invoked in an Arez transaction.
Notification when Action completes.
Flags that can be passed to configure actions.
Notification when Action starts.
Annotation applied to test methods to indicate whether the test method should be wrapped in an arez action.
Provide access to an instance of ArezContext and Arez global configuration settings.
Annotation that marks classes or interfaces to be processed by Arez annotation processor.
The ArezContext defines the top level container of interconnected observables and observers.
Annotation processor that analyzes Arez annotated source and generates models from the annotations.
Utility class for interacting with Arez config settings in tests.
Interface to intercept log messages emitted by Arez runtime.
This is a simple abstraction over browser location as a hash.
Methods and fields annotated by this annotation should be disposed when the component is disposed.
Utility methods used when returning results from repositories.
Annotation applied to test methods that indicate that observer errors should not cause the test to fail.
The component is an abstraction representation of a reactive component within Arez.
Notification when a Component is has finished being created.
Notification when a Component is starting to be created.
Methods and fields marked with this annotation are dependencies of the component.
The action to take when dependency is disposed.
Notification when a Component dispose has completed.
Notification when a Component is disposed.
Annotate the method that should return the Id for Arez component.
Marks a template method that returns the Id of the component.
A representation of a component instance exposed to spy framework.
The "kernel" of the components generated by the annotation processor.
Annotate the method that will be overridden to provide the "name" of the Arez component.
Interface implemented by components so that observers can observe the component without
observing a particular property.
Marks a template method that returns the
Component instance for the component.Annotate the method that will be overridden to return true if the component is in the specified state.
Annotate the method that will be overridden to return the value of ArezComponent.name().
The ComputableValue represents an ObservableValue derived from other ObservableValues within
the Arez system.
Flags that can configure ComputableValue instances during creation.
ComputableValue has activated.
ComputableValue has been created.
ComputableValue has de-activated.
ComputableValue has been disposed.
A representation of a ComputableValue instance exposed to spy framework.
Marks a template method that returns the
ComputableValue instance for
the Memoize annotated property.Notification when Computation completes.
Notification when Computation starts.
Marks a template method that returns the
ArezContext instance for component.Enumeration that describes the types of dependencies supported by an
Observer or a ComputableValue.A class containing width and height dimensions.
Interface that allows caller to release any resources associated with element.
Interface implemented by a component if it supports notifying listeners
when the component is disposed.
Exposes
document.visibilityState as an observable property for specified documents.The visibility state of the document.
A representation of an element exposed to spy framework.
Generic component that exposes a property as observable where changes to the variable are signalled
using a browser event.
The functional interface defining accessor.
Enum describing the executor responsible for executing the
Observer's observe method.Enum to control if a feature should be enabled.
Functional interface for returning a value.
A component that exposes the current geo position as an observable property.
Interface implemented by components so that the underlying identifier can be exposed.
An Arez browser component that tracks when the user is idle.
The Inverse annotation is used to annotate the reverse direction of the relationship annotated
by the
Reference annotation.Interface implemented by components that have references that need to be eagerly resolved.
Defines the strategy for loading references from the
Locator.The interface used to look up components by type and id.
An observable model that indicates whether a window matches a CSS media query.
Methods marked with this annotation are memoized while
activated which typically means they have an observer.
The class responsible for caching
Functional interface for calculating memoizable value.
Annotation applied to methods that define a single "contextual" parameter to one or more
Memoize
annotated methods.An observable model that declares state that tracks when the user is "online".
A node within an Arez dependency graph.
Exception thrown by repository when query produces no result when a result was expected.
Exception thrown by repository when the query for a specific entity failed.
Annotation applied to methods that expose an ObservableValue value in Arez.
An observable model that wraps a Promise and exposes observable state that track
the state of the promise.
The state of the promise.
The observable represents state that can be observed within the system.
Notification when ObservableValue has changed.
Notification when ObservableValue is created.
Notification when ObservableValue is disposed.
A representation of an ObservableValue instance exposed to spy framework.
Marks a template method that returns the
ObservableValue instance for
the Observable annotated property.Annotation that marks a method as observed.
Notification when Observer completes method being observed.
A node within Arez that is notified of changes in 0 or more Observables.
Notification when Observer is created.
Notification when Observer is disposed.
The types of errors that observers can generated.
Notification when Observer produces an error.
Interface for handling errors in observers.
A representation of a observer instance exposed to spy framework.
Notification when on observe is scheduled.
Notification when Observer is about to call method being observed.
Identifies method that is called when the
ComputableValue changes from the INACTIVE state to any other state.Identifies method that is called when the
ComputableValue changes to the INACTIVE state from
any other state.Identifies method that will be invoked when the dependencies of the paired
Observe annotated method are changed.An immutable variant of
GeolocationCoordinates.Annotation to identify method that is invoked after the component is constructed.
Annotation to identify method that is invoked after the component is disposed.
Identifies a method that will be invoked after an inverse reference is added to a component.
Annotation to identify method that is invoked before the component is disposed.
Identifies a method that will be invoked before an inverse reference is removed from a component.
Enum to control scheduling priority of observers/reactions.
Enum to control scheduling priority of observers/reactions.
Interface for performing an action that does not return a value.
Returning the value of an ObservableValue.
Changing the value of an ObservableValue.
A Reference annotation is placed on an abstract method that will resolve to a referenced object.
This annotation designates the method used to retrieve the id of the reference.
Functional interface for returning a value.
Interface for performing an action that does not return a value.
A lock that stops the scheduler from running tasks until the lock is released.
Interface used to serialize events.
Interface for interacting with spy system.
Interface for receiving spy events.
Defines the states of a component.
Indicate that the named Arez compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element).
A task represents an executable element that can be run by the task executor.
Notification that task has completed execution.
A representation of a task instance exposed to spy framework.
An interceptor that intercepts the execution of tasks.
Notification that Task is starting.
Notification when Transaction completes.
Spy interface into transaction data.
Notification when Transaction starts.
An Locator implementation where you can register a function-per type to be resolved.
Interface implemented by components that can verify their internal state.
Factory for getting observable models that sizing of windows.
An isolated Arez context.