@xh/hoist 82.0.1 → 82.0.2

package/build/types/core/HoistAppModel.d.ts

@@ -0,0 +1,72 @@
+import { AppOptionSpec, HoistModel, Thunkable } from './';
+import { Route } from 'router5';
+import { ReactNode } from 'react';
+/**
+ * Specialized base class for defining the central model for a Hoist app as specified by its
+ * See the {@link AppSpec.modelClass} config, which should reference a concrete implementation class
+ * extending this base. Hoist will create and then initialize an instance of that class after
+ * the framework has successfully initialized and will make it available to all app code via the
+ * `XH.appModel` getter.
+ *
+ * Applications should specify this class to provide application level state and services and
+ * customize important metadata. Initialization of all resources (e.g. application level services)
+ * should be done in `initAsync()`.
+ *
+ * Hoist will load/reload this Model during the global refresh process. This will occur before the
+ * application's global `XH.refreshContextModel` has been refreshed (when all mounted and 'owned'
+ * HoistModels in the application are refreshed). AppModels should implement `doLoadAsync()` if
+ * required to refresh all other app-wide services and models, respecting any ordering and phasing
+ * requirements specific to its needs.
+ */
+export declare class HoistAppModel extends HoistModel {
+    /**
+     * Hoist will call this method after Hoist services have initialized and the application
+     * has mounted. Use to trigger initialization of the app and any app-specific services.
+     *
+     * Applications will typically use this method to install and initialize app-specific
+     * services using one or more phased calls to XH.installServicesAsync().
+     */
+    initAsync(): Promise<void>;
+    /**
+     * Should the version bar be shown in this application?.
+     * Applications for which a version bar might not be appropriate (e.g. a mini-app
+     * being shown in a frame or modal) may override this getter and return false
+     */
+    get supportsVersionBar(): boolean;
+    /**
+     * Provide the initial set of Router5 Routes to be used by this application.
+     */
+    getRoutes(): Route[];
+    /**
+     * Provide a list of app-wide options to be displayed in the App's built-in Options
+     * dialog, accessible from the default AppBar menu when this method returns non-empty.
+     * @see AppOption
+     */
+    getAppOptions(): AppOptionSpec[];
+    /**
+     * Provide a list of app-wide metadata and version information to be displayed in the
+     * App's built-in About dialog.
+     */
+    getAboutDialogItems(): AboutDialogItem[];
+    /**
+     * Resets user preferences and any persistent local application state.
+     *
+     * The default implementation for this method will clear all preferences, local + session
+     * storage, and transient {@link ViewManager} state such as last-selected and pinned views.
+     * (Views themselves are preserved.)
+     *
+     * Applications may wish to override this method to perform a more targeted clearing of state.
+     * This is important for complex applications with smaller sub-applications and/or device
+     * specific applications. These applications will typically want to perform a custom clearing
+     * that is more targeted and/or clears additional app-specific state.
+     *
+     * Not typically called directly by apps - call {@link XHApi.restoreDefaultsAsync} instead.
+     */
+    restoreDefaultsAsync(): Promise<void>;
+}
+/** Object Describing an entry in the AboutDialog. */
+export interface AboutDialogItem {
+    label: ReactNode;
+    value: ReactNode;
+    omit?: Thunkable<boolean>;
+}

package/build/types/core/HoistAuthModel.d.ts

@@ -0,0 +1,70 @@
+import { HoistModel, HoistUser, IdentityInfo, PlainObject } from './';
+/**
+ *  Base class for managing authentication lifecycle.
+ *
+ *  Hoist will consult this model early in the initialization sequence, prior to full Hoist
+ *  initialization. This means that several core services (identity, configs, prefs) will *not* be
+ *  available, but it provides the app a hook to do early service initialization or other work to
+ *  support flows such as OAuth.
+ *
+ *  The base implementation of this class is minimal and would be adequate only for fully
+ *  transparent SSO based solutions such as NTLM. Applications wishing to provide custom
+ *  authentication should spec an extended version of this class in the {@link AppSpec} passed to
+ *  {@link XHApi#renderApp}.
+ */
+export declare class HoistAuthModel extends HoistModel {
+    /**
+     * Main Entry Point.
+     *
+     * This method will be called *once* by Hoist early in the app loading lifecycle to determine
+     * if full app loading can proceed.
+     *
+     * It should return true if the user could be successfully authenticated, false if the user
+     * is not authenticated, and throw in the case of technical failure. If false is returned and
+     * `AppSpec.enableLoginForm` is true the framework will enter the 'LOGIN_REQUIRED' state and
+     * show the user a form-based login with username and password fields to be submitted securely
+     * to the server.
+     *
+     * The default implementation of this method simply checks the auth status on the server, which
+     * may be appropriate for fully SSO based solutions. Override to consult or
+     * initialize third-party client resources such as OAuth.
+     *
+     * @returns identity of the user authenticated with the server; null if not authenticated.
+     */
+    completeAuthAsync(): Promise<IdentityInfo>;
+    /**
+     * @returns identity of the user authenticated with the server; null if not authenticated.
+     */
+    getAuthStatusFromServerAsync(): Promise<IdentityInfo>;
+    /**
+     * Process a manual login, submitted by user via form.
+     * @returns identity of the user authenticated with the server; null if not yet authenticated.
+     */
+    loginWithCredentialsAsync(username: string, password: string): Promise<IdentityInfo>;
+    /**
+     * Logout this user with the backend server.
+     *
+     * The default implementation will call the 'logout' endpoint on the Grails server, clearing
+     * any server-side session state there. Override to manage any client-side or third-party state.
+     */
+    logoutAsync(): Promise<void>;
+    /**
+     * Load auth-related config from the server via an /xh/ endpoint that is specifically
+     * whitelisted by Hoist to allow access prior to user authentication. For use in bootstrapping
+     * client-side auth solutions that require configs such as OAuth endpoint URLs and client IDs.
+     * See `BaseAuthenticationService.getClientConfig()` in hoist-core.
+     */
+    loadConfigAsync(): Promise<PlainObject>;
+    /**
+     * Create a client-side HoistUser.
+     *
+     * Application subclasses may override this method, but should first call the super
+     * implementation.
+     */
+    protected createUser(rawUser: PlainObject, roles: string[]): HoistUser;
+    /**
+     * Convert raw identity info as delivered by server into client-side IdentityInfo.
+     */
+    protected parseIdentityInfo(data: PlainObject): IdentityInfo;
+    private hasGate;
+}

package/build/types/core/HoistBase.d.ts

@@ -0,0 +1,179 @@
+import { comparer } from '@xh/hoist/mobx';
+import { IAutorunOptions, IReactionOptions } from 'mobx/dist/api/autorun';
+import { IEqualsComparer, IReactionDisposer } from 'mobx/dist/internal';
+import { DebounceSpec, PersistOptions, Some } from './';
+export interface HoistBaseClass {
+    new (...args: any[]): HoistBase;
+    isHoistBase: boolean;
+}
+/**
+ * Base class for objects in Hoist.
+ * Provides misc. support for Mobx integration, state persistence, and resource cleanup.
+ *
+ * This class should not typically be extended directly by applications. Applications should
+ * extend one of its subclasses instead, notably:
+ * @see HoistModel
+ * @see HoistService
+ * @see Store
+ */
+export declare abstract class HoistBase {
+    static get isHoistBase(): boolean;
+    get isHoistBase(): boolean;
+    constructor();
+    /**
+     * For XH internal use only - marks this instance as created by and for Hoist as part of its
+     * own implementation. Used as a filter within Hoist Inspector to distinguish services and
+     * models that are either created directly by the app developer or important/public parts of
+     * the Hoist API from those that are not.
+     * @internal
+     */
+    xhImpl: boolean;
+    private managedInstances;
+    private disposers;
+    private _destroyed;
+    private _xhImpl;
+    /** Default persistence options for this object. */
+    persistWith: PersistOptions;
+    logInfo(...messages: unknown[]): void;
+    logWarn(...messages: unknown[]): void;
+    logError(...messages: unknown[]): void;
+    logDebug(...messages: unknown[]): void;
+    withInfo<T>(messages: Some<unknown>, fn: () => T): T;
+    withDebug<T>(messages: Some<unknown>, fn: () => T): T;
+    /**
+     * Add and start one or more managed reactions.
+     *
+     * A reaction's run function will be executed on changes to any/all observables read in its
+     * track function, regardless of whether they - or any other observables - are accessed in
+     * the run function. The reaction will also run only when the output of the track function
+     * changes, and this output is passed to the run function.
+     *
+     * Specify the property 'track' to run the reaction continuously until disposal.
+     * Alternatively, specify the 'when' property to run this reaction only until the predicate
+     * passes, and the run function is executed once. (These map to mobX's native `reaction()`
+     * and `when()` functions, respectively).
+     *
+     * Specify the property 'equals' to determine how successive outputs of track will be compared.
+     * Hoist supports string specification of this (i.e. 'shallow','structural', or 'identity') and
+     * will map it to the underlying MobX `comparer` object.  For returns of arrays and objects,
+     * consider using the value 'shallow' over the default 'identity' to avoid triggering spurious
+     * changes. See MobX for more information.
+     *
+     * Choose this method over an autorun when you wish to explicitly declare which observables
+     * should be tracked. A common pattern is to have the track function return these
+     * observables in a simple array or object, which the run function can use as its input or
+     * (commonly) ignore. This helps to clarify that the track function is only enumerating
+     * the observables to be watched, and not necessarily generating or transforming values.
+     *
+     * Set `fireImmediately: true` to execute the `run` function once immediately with the
+     * current value of the tracked expression, rather than waiting for it to change. This is
+     * useful for syncing initial state without duplicating logic outside the reaction.
+     *
+     *  Reactions created in this method will be disposed of automatically when this object is
+     *  destroyed. They can also be ended/disposed of manually using the native MobX disposer
+     *  functions returned by this method.
+     *
+     * @param specs - one or more reactions to add
+     * @returns disposer(s) to manually dispose of each created reaction.
+     */
+    addReaction<T>(spec: ReactionSpec<T>): IReactionDisposer;
+    addReaction<T extends any[]>(...specs: {
+        [K in keyof T]: ReactionSpec<T[K]>;
+    }): IReactionDisposer[];
+    /**
+     * Add and start one or more managed autoruns.
+     *
+     * An autorun function will be run on changes to any/all observables read during the last
+     * execution of the function. This provides convenient and often very efficient dynamic
+     * reactivity. This is a core MobX concept and is important to fully understand when
+     * using autorun functions.
+     *
+     * In some cases, however, it is desirable or more clear to explicitly declare which
+     * observables should be tracked and trigger a reaction, regardless of their use within
+     * the function itself. See addReaction() above for that functionality.
+     *
+     * Autoruns created in this method will be disposed of automatically when this object is
+     * destroyed. They can also be ended/disposed of manually using the native mobx disposer
+     * functions returned by this method.
+     *
+     * @param specs - one or more autoruns to add
+     * @returns disposer(s) to manually dispose of each created autorun.
+     */
+    addAutorun(...specs: Array<AutoRunSpec | (() => any)>): IReactionDisposer | Array<IReactionDisposer>;
+    /**
+     * Set an observable/bindable value.
+     *
+     * This method is a convenience method for calling the conventional setXXX method
+     * for updating a mobx observable given the property name.
+     */
+    setBindable(property: string, value: any): void;
+    /** @returns a unique id for this object within the lifetime of this document. */
+    get xhId(): string;
+    /**
+     * Mark an object as managed by this object.
+     *
+     * Managed objects are assumed to hold objects that are created by the referencing object
+     * and therefore should be destroyed when the referencing object is destroyed.
+     *
+     * See also {@link managed}, a decorator that can be used to mark any object held within
+     * a given property as managed.
+     *
+     * @param obj - object to be destroyed when this instance is destroyed
+     * @returns object passed
+     */
+    markManaged<T>(obj: T): T;
+    /**
+     *  Method to make a class property persistent, syncing its value via a configured
+     * `PersistenceProvider` to maintain and restore values across browser sessions.
+     *
+     * This may be used on any `@observable` or `@bindable` class property which is a primitive.
+     * It will initialize the observable's value from the class's default `PersistenceProvider` and
+     * will write back any changes to the property to that Provider. If the Provider has not yet
+     * been populated with a value, or an error occurs, it will use the value set in-code instead.
+     *
+     * See also {@link persist} and {@link persist.with} for a decorator that may be used directly
+     * on the property declaration itself. Use this method in the general case, when you need to
+     * control the timing.
+     *
+     * @param property - name of property on this object to bind to a persistence provider.
+     * @param options - options governing the persistence of this object. These will be applied
+     *      on top of any default persistWith options defined on the instance itself.
+     */
+    markPersist<P extends keyof this & string>(property: P, options?: PersistOptions): void;
+    /** @returns true if this instance has been destroyed. */
+    get isDestroyed(): boolean;
+    /**
+     * Clean up resources associated with this object.
+     */
+    destroy(): void;
+}
+/**
+ * Object containing options accepted by MobX 'reaction' API as well as arguments below.
+ * Also supports MobX options inherited from IReactionOptions, including `fireImmediately`
+ * (run the reaction once immediately with the current tracked value).
+ */
+export interface ReactionSpec<T = any> extends Omit<IReactionOptions<T, any>, 'equals'> {
+    /**
+     * Function returning data to observe - first arg to the underlying reaction() call.
+     * Specify this or `when`.
+     */
+    track?: () => T;
+    /**
+     * Function determining when reaction should fire - first arg to the underlying when() call.
+     * Specify this or `track`.
+     */
+    when?: () => boolean;
+    /** Function to run - second arg to underlying reaction()/when() call. */
+    run?: (curr?: T, prev?: T) => void;
+    /** Specify to debounce run function */
+    debounce?: DebounceSpec;
+    /** Specify a default from {@link comparer} or a custom comparer function. */
+    equals?: keyof typeof comparer | IEqualsComparer<T>;
+}
+/**
+ * Object containing options accepted by MobX 'autorun' API as well as arguments below.
+ */
+export interface AutoRunSpec extends IAutorunOptions {
+    /** Function to run - first arg to underlying autorun() call. */
+    run?: () => void;
+}

package/build/types/core/HoistBaseDecorators.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Decorator to make a property "managed". Managed properties are designed to hold objects that
+ * are created by the referencing object and that implement a `destroy()` method.
+ *
+ * @see HoistBase.markManaged
+ */
+export declare const managed: any;
+/**
+ * Decorator to make a class property persistent.
+ *
+ * This decorator provides the same functionality as {@link HoistBase.markPersist}. See that method
+ * for more details.
+ *
+ * This decorator should always be applied "before" the mobx decorator, i.e. second in file line
+ * order: `@bindable @persist fooBarFlag = true`
+ *
+ * See also `@persist.with`, a higher-order version of this decorator that allows for setting
+ * property-specific persistence options.
+ */
+export declare const persist: any;

package/build/types/core/HoistComponent.d.ts

@@ -0,0 +1,112 @@
+import { HoistProps, DefaultHoistProps, ElementFactory } from './';
+import { ModelSpec, HoistModel } from './model';
+import { ForwardedRef, FC, ReactNode } from 'react';
+/**
+ * Type representing props passed to a HoistComponent's render function.
+ *
+ * This type removes from its base type several properties that are pulled out by the HoistComponent itself and
+ * not provided to the render function.  `modelConfig` and `modelRef` are resolved into the `model` property.
+ * `ref` is passed as the second argument to the render function.
+ */
+export type RenderPropsOf<P extends HoistProps> = P & {
+    /** Pre-processed by HoistComponent internals into a mounted model.  Never passed to render. */
+    modelConfig: never;
+    /** Pre-processed by HoistComponent internals and attached to model.  Never passed to render. */
+    modelRef: never;
+    /** Pre-processed by HoistComponent internals and passed as second argument to render. */
+    ref: never;
+};
+/**
+ * Configuration for creating a Component.  May be specified either as a render function,
+ * or an object containing a render function and associated metadata.
+ */
+export type ComponentConfig<P extends HoistProps> = ((props: RenderPropsOf<P>, ref?: ForwardedRef<any>) => ReactNode) | {
+    /** Render function defining the component. */
+    render(props: RenderPropsOf<P>, ref?: ForwardedRef<any>): ReactNode;
+    /**
+     * Spec defining the model to be rendered by this component.
+     * Specify as false for components that don't require a primary model. Otherwise, set to the
+     * return of {@link uses} or {@link creates} - these factory functions will create a spec for
+     * either externally-provided or internally-created models. Defaults to `uses('*')`.
+     */
+    model?: ModelSpec<P['model']> | false;
+    /**
+     * Base CSS class for this component. Will be combined with any className
+     * in props, with the combined string passed into render as a prop.
+     */
+    className?: string;
+    /** Component name for debugging/inspection. */
+    displayName?: string;
+    /**
+     * True (default) to wrap component in a call to `React.memo()`.
+     * Components that are known to be unable to make effective use of memo (e.g. container
+     * components) may set this to `false`. Not typically set by application code.
+     */
+    memo?: boolean;
+    /**
+     *  True (default) to enable MobX-powered reactivity via the
+     * `observer()` HOC from mobx-react. Components that are known to dereference no observable
+     *  state may set this to `false`, but this is not typically done by application code.
+     */
+    observer?: boolean;
+};
+/**
+ * Hoist utility for defining functional components. This is the primary method for creating
+ * components for use in Hoist applications. Accepts either a render function (directly) or a
+ * configuration object to specify that function and additional options, as described below.
+ *
+ * The primary additional config option is `model`. It specifies how a backing HoistModel will be
+ * provided to / created by this component and if the component should publish its model to any
+ * subcomponents via context.
+ *
+ * By default, this utility wraps the returned component in the MobX 'observer' HOC, enabling
+ * MobX-powered reactivity and auto-re-rendering of observable properties read from models and
+ * any other sources of observable state.
+ *
+ * Forward refs {@link https://reactjs.org/docs/forwarding-refs.html} are supported by specifying a
+ * render function that accepts two arguments. In that case, the second arg will be considered a
+ * ref, and this utility will apply `React.forwardRef` as required.
+ *
+ * @param config - specification object, or a render function defining the component.
+ * @returns a functional React Component for use within Hoist apps.
+ *
+ * @see hoistCmp - a shorthand alias to this function.
+ *
+ * This function also has several related functions
+ *
+ *   - `hoistCmp.factory` - return an elementFactory for a newly defined Component.
+ *           instead of the Component itself.
+ *
+ *   - `hoistCmp.withFactory` - return a 2-element list containing both the newly
+ *          defined Component and an elementFactory for it.
+ */
+export declare function hoistCmp<M extends HoistModel>(config: ComponentConfig<DefaultHoistProps<M>>): FC<DefaultHoistProps<M>>;
+export declare function hoistCmp<P extends HoistProps>(config: ComponentConfig<P>): FC<P>;
+export declare namespace hoistCmp {
+    var factory: typeof hoistCmpFactory;
+    var withFactory: typeof hoistCmpWithFactory;
+}
+/**
+ * Alias for {@link hoistCmp}.
+ */
+export declare const hoistComponent: typeof hoistCmp;
+/**
+ * Return an element factory for a newly defined component.
+ *
+ * Most typically used by application, this provides a simple element factory.
+ */
+export declare function hoistCmpFactory<M extends HoistModel>(config: ComponentConfig<DefaultHoistProps<M>>): ElementFactory<DefaultHoistProps<M>>;
+export declare function hoistCmpFactory<P extends HoistProps>(config: ComponentConfig<P>): ElementFactory<P>;
+/**
+ * Returns a 2-element list containing both the newly defined Component and an elementFactory for it.
+ * Used by Hoist for exporting Component artifacts that support both JSX and elementFactory based development.
+ *
+ * Not typically used by applications.
+ */
+export declare function hoistCmpWithFactory<M extends HoistModel>(config: ComponentConfig<DefaultHoistProps<M>>): [FC<DefaultHoistProps<M>>, ElementFactory<DefaultHoistProps<M>>];
+export declare function hoistCmpWithFactory<P extends HoistProps>(config: ComponentConfig<P>): [FC<P>, ElementFactory<P>];
+/**
+ * Component to render certain errors caught within hoistComponent.
+ * @internal
+ */
+export declare function setCmpErrorDisplay(ef: ElementFactory): void;

package/build/types/core/HoistProps.d.ts

@@ -0,0 +1,116 @@
+import { HoistModel } from '@xh/hoist/core';
+import { Property } from 'csstype';
+import { CSSProperties, HTMLAttributes, LegacyRef, ReactNode, Ref } from 'react';
+/**
+ * Props interface for Hoist Components.
+ *
+ * This interface brings in additional properties that are added to the props
+ * collection by HoistComponent.
+ */
+export interface HoistProps<M extends HoistModel = HoistModel> {
+    /**
+     * Associated HoistModel for this Component.  Depending on the component, may be specified as
+     * an instance of a HoistModel, or a configuration object to create one, or left undefined.
+     * HoistComponent will resolve (i.e. lookup in context or create if needed) a concrete Model
+     * instance and provide it to the Render method of the component.
+     */
+    model?: M;
+    /**
+     * Used for specifying the *configuration* of a model to be created by Hoist for this component
+     * when first mounted.  Should be used only on a component that specifies the 'uses()' directive
+     * with the `createFromConfig` set as true. See the `uses()` directive for more information.
+     */
+    modelConfig?: M extends null ? never : M['config'];
+    /**
+     * Used for gaining a reference to the model of a HoistComponent.
+     */
+    modelRef?: M extends null ? never : Ref<M>;
+    /**
+     * ClassName for the component.  Includes the classname as provided in props, enhanced with
+     * any base class name provided by the component definition itself.
+     */
+    className?: string;
+    /** React children. */
+    children?: ReactNode;
+    /** React Ref for this component. */
+    ref?: LegacyRef<any>;
+}
+/**
+ * A version of Hoist props that allows dynamic keys/properties.   This is the interface that
+ * Hoist uses for components that do not explicitly specify the type of props they expect.
+ *
+ * This behavior is useful for file or package-local components that do not require an explicit
+ * props API.
+ */
+export interface DefaultHoistProps<M extends HoistModel = HoistModel> extends HoistProps<M> {
+    [x: string]: any;
+}
+/**
+ * Props for Components that support standard Layout attributes
+ *
+ * Most component will typically separate these props out and pass them along to another component
+ * which also supports this interface.  Eventually, they should be passed to a Box class.
+ */
+export interface BoxProps extends LayoutProps, TestSupportProps, Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'contextMenu'> {
+}
+/**
+ * Props for Components that accept standard HTML `style` attributes.
+ */
+export interface StyleProps {
+    style?: CSSProperties;
+}
+/**
+ * Props to support reliable selection of components for automated testing.
+ */
+export interface TestSupportProps {
+    /**
+     * Unique identifier for this component for the purposes of locating and interacting with
+     * its primary/outer DOM element using automated testing tools. Hoist components that support
+     * this interface will add a "data-testid" attribute to an appropriate DOM element - typically
+     * (but not always) the outermost tag in their rendered markup. Some components may generate
+     * and apply additional child testIds to support testing of nested elements.
+     */
+    testId?: string;
+}
+export interface LayoutProps {
+    margin?: string | number | boolean;
+    marginTop?: string | number | boolean;
+    marginRight?: string | number | boolean;
+    marginBottom?: string | number | boolean;
+    marginLeft?: string | number | boolean;
+    padding?: string | number | boolean;
+    paddingTop?: string | number | boolean;
+    paddingRight?: string | number | boolean;
+    paddingBottom?: string | number | boolean;
+    paddingLeft?: string | number | boolean;
+    height?: string | number;
+    minHeight?: string | number;
+    maxHeight?: string | number;
+    width?: string | number;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    flex?: string | number;
+    flexBasis?: string | number;
+    flexDirection?: Property.FlexDirection;
+    flexFlow?: Property.FlexFlow;
+    flexGrow?: string | number;
+    flexShrink?: string | number;
+    flexWrap?: Property.FlexWrap;
+    gap?: string | number | boolean;
+    alignItems?: string;
+    alignSelf?: string;
+    alignContent?: string;
+    justifyContent?: string;
+    overflow?: string;
+    overflowX?: Property.OverflowX;
+    overflowY?: Property.OverflowY;
+    textOverflow?: string;
+    top?: string | number;
+    left?: string | number;
+    position?: Property.Position;
+    display?: string;
+}
+/** LayoutProps after resolution by `getLayoutProps()`, with boolean values resolved. */
+export type ResolvedLayoutProps = {
+    [K in keyof LayoutProps]: Exclude<LayoutProps[K], boolean>;
+};

package/build/types/core/HoistService.d.ts

@@ -0,0 +1,57 @@
+import { HoistBase, LoadSupport, LoadSpec, Loadable, PlainObject, TaskObserver } from './';
+/**
+ * Core superclass for Services in Hoist. Services are special classes used in both Hoist and
+ * application code as centralized points for managing app-wide state and loading / processing
+ * data from external APIs.
+ *
+ * Services are distinct from Models in that they are typically constructed and initialized within
+ * either `XH` (for Hoist-provided services) or within the `initAsync()` method of your primary
+ * `AppModel` - see {@link XH.installServicesAsync}. A single instance of each service is
+ * constructed and installed as a property on the `XH` singleton.
+ *
+ * (E.g. an app that defines and initializes a custom `TradeEntryService` class can access and use
+ * that instance as `XH.tradeEntryService`. This mirrors the pattern for singleton service
+ * injection used within the Grails server.)
+ *
+ * Services are most commonly used as engines within an application for loading, processing, and
+ * potentially caching data, although keep in mind their singleton nature when maintaining and
+ * updating state within your service. (E.g. if your service caches business objects and hands them
+ * out to callers, take care that those shared objects aren't modified by callers in unexpectedly
+ * shared ways.)
+ *
+ * Services extend `HoistBase` and can therefore leverage MobX-powered observables and reactions if
+ * so desired. And while components should typically source their state from backing models, they
+ * can also read and react to service state and call service APIs.
+ */
+export declare class HoistService extends HoistBase implements Loadable {
+    _created: number;
+    static get isHoistService(): boolean;
+    get isHoistService(): boolean;
+    constructor();
+    /**
+     * Called by framework or application to initialize before application startup.
+     * Throwing an exception from this method will typically block startup.
+     * Service writers should take care to stifle and manage all non-fatal exceptions.
+     */
+    initAsync(): Promise<void>;
+    /**
+     * Provides optional support for Hoist's approach to managed loading.
+     *
+     * Applications will not typically need to access this object directly. If a subclass
+     * declares a concrete implementation of the `doLoadAsync()` template method, an instance of
+     * `LoadSupport` will automatically be created and installed to support the extensions below.
+     */
+    loadSupport: LoadSupport;
+    get loadObserver(): TaskObserver;
+    get loadModel(): TaskObserver;
+    get lastLoadRequested(): Date;
+    get lastLoadCompleted(): Date;
+    get lastLoadException(): any;
+    refreshAsync(meta?: PlainObject): Promise<void>;
+    autoRefreshAsync(meta?: PlainObject): Promise<void>;
+    doLoadAsync(loadSpec: LoadSpec): Promise<void>;
+    loadAsync(loadSpec?: LoadSpec | Partial<LoadSpec>): Promise<void>;
+}
+export interface HoistServiceClass<T extends HoistService = HoistService> {
+    new (): T;
+}

package/build/types/core/RefreshContextView.d.ts

@@ -0,0 +1,10 @@
+import { RefreshContextModel } from './model';
+/**
+ * Establishes an area of the application with an independent RefreshContextModel.
+ *
+ * The model established by this view will be refreshed by its parent context but may also be refreshed
+ * independently.
+ *
+ * @see RefreshContextModel
+ */
+export declare const RefreshContextView: import("react").FC<import("./HoistProps").DefaultHoistProps<RefreshContextModel>>, refreshContextView: import("./elem").ElementFactory<import("./HoistProps").DefaultHoistProps<RefreshContextModel>>;