@xh/hoist 82.0.1 → 82.0.3

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

@@ -0,0 +1,80 @@
+import { ReactNode } from 'react';
+/**
+ * Tracks the execution state of one or more asynchronous tasks.
+ *
+ * An instance of this class can be used to control masks or other UI elements that
+ * track the progression of asynchronous tasks. It can be passed directly to a Panel
+ * component via its `mask` property, providing a common and convenient
+ * method for masking a section of a user interface while an operation is pending.
+ */
+export declare class TaskObserver {
+    /**
+     * Create a new TaskObserver that will be pending if *any* linked
+     * subtasks is still pending.
+     */
+    static trackAll({ tasks, message }?: {
+        tasks?: TaskObserver[];
+        message?: string;
+    }): TaskObserver;
+    /**
+     * Create a new TaskObserver that will be pending if its *last* linked
+     * subtask is still pending.
+     *
+     * Useful for tracking repeated invocations of the same operation, such as
+     * serially reloading of data from the server.
+     */
+    static trackLast({ message }?: {
+        message?: string;
+    }): TaskObserver;
+    /**
+     * Create a TaskObserver bound to a single Promise.
+     * @see {@link Promise.linkTo} - preferred way to link an existing TaskObserver to a promise.
+     * @internal
+     */
+    static forPromise({ promise, message }: {
+        promise: any;
+        message: any;
+    }): PromiseObserver;
+    get isTaskObserver(): boolean;
+    /**
+     * Is the task considered to be executing/in-progress? Observable.
+     */
+    get isPending(): boolean;
+    /**
+     * The number of pending tasks. Observable.
+     */
+    get pendingCount(): number;
+    /**
+     * The message describing the executing task. Observable.
+     */
+    get message(): ReactNode;
+    /**
+     *  Set the message describing the executing task.
+     */
+    setMessage(msg: ReactNode): void;
+    /**
+     * Link the task to a subtask.
+     */
+    linkTo(task: TaskObserver): void;
+    /**
+     * Clear any tasks currently being observed.
+     */
+    clear(): void;
+    /**
+     * This class is abstract and should not be instantiated directly. To get an instance of this
+     * class, use static methods trackFirst(), trackLast() or fromPromise().
+     * @internal
+     */
+    constructor();
+}
+declare class PromiseObserver extends TaskObserver {
+    private _isPending;
+    private _message;
+    get isPromiseObserver(): boolean;
+    get isPending(): boolean;
+    get pendingCount(): 1 | 0;
+    get message(): ReactNode;
+    clear(): void;
+    constructor(promise: any, message: any);
+}
+export {};

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

@@ -0,0 +1,445 @@
+import { RouterModel } from '@xh/hoist/appcontainer/RouterModel';
+import { HoistAuthModel } from '@xh/hoist/core/HoistAuthModel';
+import { Store } from '@xh/hoist/data';
+import { AlertBannerService, AutoRefreshService, ChangelogService, ClientHealthService, ConfigService, EnvironmentService, FetchOptions, FetchService, GridAutosizeService, GridExportService, IdentityService, IdleService, InspectorService, JsonBlobService, LocalStorageService, PrefService, SessionStorageService, TrackService, WebSocketService } from '@xh/hoist/svc';
+import { LogLevel } from '@xh/hoist/utils/js';
+import { Router, State } from 'router5';
+import { CancelFn } from 'router5/types/types/base';
+import { SetOptional } from 'type-fest';
+import { AppContainerModel } from '../appcontainer/AppContainerModel';
+import { BannerModel } from '../appcontainer/BannerModel';
+import { ToastModel } from '../appcontainer/ToastModel';
+import '../styles/XH.scss';
+import { HoistException } from '../exception';
+import { AppSpec, AppState, AppSuspendData, BannerSpec, ExceptionHandler, ExceptionHandlerOptions, HoistAppModel, HoistService, HoistServiceClass, HoistUser, MessageSpec, PageState, PlainObject, ReloadAppOptions, SizingMode, TaskObserver, Theme, ToastSpec, TrackOptions } from './';
+import { HoistModel, ModelSelector, RefreshContextModel } from './model';
+export declare const MIN_HOIST_CORE_VERSION = "31.2";
+/**
+ * Top-level Singleton model for Hoist. This is the main entry point for the API.
+ *
+ * Provides access to the built-in Hoist services, metadata about the application and environment,
+ * and convenience aliases to the most common framework operations.
+ *
+ * Available via import as `XH` - also installed as `window.XH` for troubleshooting purposes.
+ */
+export declare class XHApi {
+    /** Unique id for this loaded instance of the app.  Unique for every refresh of document. */
+    loadId: string;
+    /**
+     * Unique id for this browser tab/window on this domain.
+     * Corresponds to the scope of the built-in sessionStorage object.
+     */
+    tabId: string;
+    /** Core implementation model hosting all application state. */
+    appContainerModel: AppContainerModel;
+    /** Provider of centralized exception handling for the app. */
+    exceptionHandler: ExceptionHandler;
+    /** Short internal code for the application. */
+    readonly appCode: string;
+    /** User-facing display name for the app. See also {@link clientAppName}. */
+    readonly appName: string;
+    /** SemVer or snapshot version of the client build. */
+    readonly appVersion: string;
+    /**
+     * Optional identifier for the client build (e.g. a git commit hash or a build ID).
+     * Varies depending on an app's particular build configuration.
+     */
+    readonly appBuild: string;
+    /** Root URL context/path - prepended to all relative fetch requests. */
+    readonly baseUrl: string;
+    /** List of all client app codes available in the application. */
+    readonly clientApps: string[];
+    /** True if the app is running in a local development environment. */
+    readonly isDevelopmentMode: boolean;
+    /** Authentication Model for this App. */
+    authModel: HoistAuthModel;
+    alertBannerService: AlertBannerService;
+    autoRefreshService: AutoRefreshService;
+    changelogService: ChangelogService;
+    clientHealthService: ClientHealthService;
+    configService: ConfigService;
+    environmentService: EnvironmentService;
+    fetchService: FetchService;
+    gridAutosizeService: GridAutosizeService;
+    gridExportService: GridExportService;
+    identityService: IdentityService;
+    idleService: IdleService;
+    inspectorService: InspectorService;
+    jsonBlobService: JsonBlobService;
+    localStorageService: LocalStorageService;
+    prefService: PrefService;
+    sessionStorageService: SessionStorageService;
+    trackService: TrackService;
+    webSocketService: WebSocketService;
+    /**
+     * Tracks globally loading promises.
+     * Apps should link any async operations that should mask the entire viewport to this observer.
+     */
+    get appLoadObserver(): TaskObserver;
+    get appLoadModel(): TaskObserver;
+    /** Root level application model. */
+    get appModel(): HoistAppModel;
+    /** Specifications for this application, provided in call to `XH.renderApp()`. */
+    get appSpec(): AppSpec;
+    /** Short code for this particular JS client application. */
+    get clientAppCode(): string;
+    /** Display name for this particular JS client application. */
+    get clientAppName(): string;
+    /** True if the app should use the Hoist mobile toolkit.*/
+    get isMobileApp(): boolean;
+    /** True if the app is running on a desktop. */
+    get isDesktop(): boolean;
+    /** True if the app is running on a mobile phone. */
+    get isPhone(): boolean;
+    /** True if the app is running on a tablet. */
+    get isTablet(): boolean;
+    /** The global RefreshContextModel for this application.*/
+    get refreshContextModel(): RefreshContextModel;
+    /**
+     * Current lifecycle state of the application. (observable)
+     * The {@link AppState} type lists the possible states, with descriptive comments.
+     */
+    get appState(): AppState;
+    /** Shortcut for testing if appState is 'RUNNING'. (observable) */
+    get appIsRunning(): boolean;
+    /** Milliseconds timestamp for the last time user interaction with the page was detected. */
+    get lastActivityMs(): number;
+    /**
+     * The lifecycle state of the page. (observable)
+     *
+     * This state changes due to changes to the focused/visible state of the browser tab and the
+     * browser window as a whole, as well as built-in browser behaviors around navigation and
+     * performance optimizations.
+     *
+     * Apps can react to this stat to pause background processes (e.g. expensive refreshes) when
+     * the app is no longer visible to the user and resume them when the user switches back and
+     * re-activates the tab.
+     *
+     * The {@link PageState} type lists the possible states, with descriptive comments.
+     * See {@link https://developer.chrome.com/blog/page-lifecycle-api/} for a useful overview.
+     */
+    get pageState(): PageState;
+    /** Shortcut for testing if pageState is 'active'. (observable) */
+    get pageIsActive(): boolean;
+    /** Shortcut for testing if pageState is 'passive'. (observable) */
+    get pageIsPassive(): boolean;
+    /** Shortcut for testing if pageState is 'active' or 'passive'. (observable) */
+    get pageIsVisible(): boolean;
+    /**
+     * Send a request via the underlying fetch API.
+     * @see FetchService.fetch
+     */
+    fetch(opts: FetchOptions): Promise<any>;
+    /**
+     * Send an HTTP request and decode the response as JSON.
+     * @see FetchService.fetchJson
+     */
+    fetchJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Send a POST request with a JSON body and decode the response as JSON.
+     * @see FetchService.postJson
+     */
+    postJson(opts: FetchOptions): Promise<any>;
+    /**
+     * Read soft configuration values.
+     * @see ConfigService.get
+     */
+    getConf(key: string, defaultVal?: any): any;
+    /**
+     * Read user preference values.
+     * @see PrefService.get
+     */
+    getPref(key: string, defaultVal?: any): any;
+    /**
+     * Set user preference values.
+     * @see PrefService.set
+     */
+    setPref(key: string, val: any): void;
+    /**
+     * Track user activity.
+     * @see TrackService.track
+     */
+    track(opts: string | TrackOptions): void;
+    /**
+     * Read an environment property.
+     * @see EnvironmentService.get
+     */
+    getEnv(key: string): any;
+    /**
+     * @returns the current acting user.
+     * @see IdentityService.user
+     */
+    getUser(): HoistUser;
+    /**
+     * @returns the current acting user's username.
+     * @see IdentityService.username
+     */
+    getUsername(): string;
+    /** @returns the current acting user's initials. */
+    getUserInitials(): string;
+    /**
+     * Logout the current user.
+     * @see HoistAuthModel.logoutAsync
+     */
+    logoutAsync(): Promise<void>;
+    /**
+     * Current minimum severity for Hoist log utils (default 'info').
+     * Messages logged via managed Hoist log utils with lower severity will be ignored.
+     */
+    get logLevel(): LogLevel;
+    /**
+     * Set the minimum severity for Hoist log utils.
+     * Optionally persist this adjustment for up to 1440 minutes in local storage.
+     */
+    setLogLevel(level: LogLevel, persistMins?: number): void;
+    /**
+     * Short cut to enable client-side logging at level `debug`.
+     * Optionally persist this adjustment for up to 1440 minutes in local storage.
+     *
+     * Hint: call this method from the console to show more verbose data while troubleshooting.
+     */
+    enableDebugLogging(persistMins?: number): void;
+    /**
+     * Main entry point to start the client app - initializes and renders application code.
+     * Call from the app's entry-point file within your project's `/client-app/src/apps/` folder.
+     */
+    renderApp<T extends HoistAppModel>(appSpec: AppSpec<T>): void;
+    /**
+     * Entry-point to start the Hoist Admin console app, with common properties defaulted.
+     * Call this from within your project's `/client-app/src/apps/admin.ts` file.
+     *
+     * NOTE you must still import and pass in the `componentClass`, `containerClass`, and
+     * `modelClass` options. We don't default those here, as we do not want to import admin-only
+     * code in XH, where it would be added to the bundles for all client apps.
+     */
+    renderAdminApp<T extends HoistAppModel>(appSpec: SetOptional<AppSpec<T>, 'isMobileApp' | 'checkAccess'>): void;
+    /**
+     * Suspend all app activity and display, including timers and web sockets.
+     *
+     * Suspension is a terminal state, requiring user to reload the app.
+     * Used for idling, forced version upgrades, and ad-hoc killing of problematic clients.
+     */
+    suspendApp(suspendData: AppSuspendData): void;
+    /**
+     * Trigger a full reload of the current application.
+     *
+     * @param opts - options to govern reload. To support legacy usages, a provided
+     *       string will be treated as `ReloadAppOptions.path`.
+     *
+     * This method will reload the entire application document in the browser - to trigger a
+     * refresh of the loadable content within the app, use {@link refreshAppAsync} instead.
+     */
+    reloadApp(opts?: ReloadAppOptions | string): void;
+    /**
+     * Refresh the current application.
+     *
+     * This method will do an "in-place" refresh of the loadable content as defined by the app.
+     * It is a short-cut to `XH.refreshContextModel.refreshAsync()`.
+     *
+     * To trigger a full reload of the app document in the browser (including code) use
+     * {@link reloadApp} instead.
+     */
+    refreshAppAsync(): Promise<void>;
+    /**
+     * Open a url in an external browser window/tab.
+     *
+     * Unlike a simple call to `open`, this method ensures the "opener" method on the
+     * new window is null. This ensures that the new page will not share sessionState with
+     * this page.  See https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage
+     */
+    openWindow(url: string, target?: string): void;
+    /**
+     * Flags for controlling experimental, hotfix, or otherwise provisional features.
+     *
+     * Configure via `xhFlags` config.
+     *
+     * No flags currently supported (subject to changes without API notice):
+     */
+    get flags(): PlainObject;
+    /** Toggle the theme between light and dark variants. */
+    toggleTheme(): void;
+    /** Set the theme directly (useful for custom app option controls). */
+    setTheme(value: Theme, persist?: boolean): void;
+    /** True if the dark theme is currently active. (observable) */
+    get darkTheme(): boolean;
+    /** Standard size used by Grid. (observable) */
+    get sizingMode(): SizingMode;
+    /** Set standard size used by Grid. */
+    setSizingMode(sizingMode: SizingMode): void;
+    /** Current viewport width / height. (observable) */
+    get viewportSize(): {
+        width: number;
+        height: number;
+    };
+    /** True if the viewport is currently in the portrait orientation. (observable) */
+    get isPortrait(): boolean;
+    /** True if the viewport is currently in the landscape orientation. (observable) */
+    get isLandscape(): boolean;
+    /**
+     * Model hosting observable router5 state. Not typically used by applications.
+     * Use {@link routerState} instead.
+     */
+    get routerModel(): RouterModel;
+    /**
+     * Underlying Router5 Router object implementing the routing state.
+     * Applications should use this property to directly access the Router5 API.
+     */
+    get router(): Router;
+    /**
+     * The current routing state of the application. (observable)
+     * @see RoutingManager.currentState
+     */
+    get routerState(): State;
+    /** Route the app - shortcut to `XH.router.navigate()`. */
+    navigate(...args: any[]): CancelFn;
+    /** Add a routeName to the current route, preserving params. */
+    appendRoute(routeName: string, newParams?: PlainObject): CancelFn;
+    /** Remove last routeName from the current route, preserving params. */
+    popRoute(): CancelFn;
+    /**
+     * Show a modal message dialog.
+     *
+     * Note that this method will autofocus the confirm button by default. To focus the cancel
+     * button instead (e.g. for confirming risky operations), applications should specify a
+     * `cancelProps` argument of the following form `cancelProps: {..., autoFocus: true}`.
+     *
+     * @returns true if user confirms, false if user cancels. If an input is provided, the
+     * returned Promise will resolve to the input value if user confirms, false if user cancels.
+     */
+    message<T = unknown>(config: MessageSpec): Promise<T | boolean>;
+    /**
+     * Show a modal 'alert' dialog with message and default 'OK' button.
+     * @returns true when user acknowledges alert.
+     */
+    alert(config: MessageSpec): Promise<boolean>;
+    /**
+     * Show a modal 'confirm' dialog with message and default 'OK'/'Cancel' buttons.
+     * @returns true if user confirms, false if user cancels.
+     */
+    confirm(config: MessageSpec): Promise<boolean>;
+    /**
+     * Show a modal 'prompt' dialog with a default TextInput, message and 'OK'/'Cancel' buttons.
+     *
+     * The default TextInput comes with props set for:
+     *   1. autoFocus = true
+     *   2. selectOnFocus = true (desktop only)
+     *   3. onKeyDown handler to confirm on <enter> (same as clicking 'OK') (desktop only)
+     * Applications may also provide a custom HoistInput, in which all props must be set.
+     *
+     * @returns value of input if user confirms, false if user cancels.
+     */
+    prompt<T = unknown>(config: MessageSpec): Promise<T | false>;
+    /**
+     * Show a non-modal "toast" notification that appears and then automatically dismisses.
+     * @returns model representing the toast. May be used for programmatic dismissal.
+     */
+    toast(config: ToastSpec | string): ToastModel;
+    /** Show a toast with default intent and icon indicating success. */
+    successToast(config: ToastSpec | string): ToastModel;
+    /** Show a toast with default intent and icon indicating a warning. */
+    warningToast(config: ToastSpec | string): ToastModel;
+    /** Show a toast with intent and icon indicating a serious issue. */
+    dangerToast(config: ToastSpec | string): ToastModel;
+    /**
+     * Show a Banner across the top of the viewport. Banners are unique by their category prop.
+     * Showing a new banner with an existing category name will replace the previous banner.
+     */
+    showBanner(spec: BannerSpec | string): BannerModel;
+    /** Hide banner by category name. */
+    hideBanner(category?: string): void;
+    /**
+     * Handle an exception. This method is an alias for {@link ExceptionHandler.handleException}.
+     *
+     * This method may be called by applications in order to provide logging, reporting, and
+     * display of exceptions. It is typically called directly in catch() blocks.
+     *
+     * See also Promise.catchDefault(). That method will delegate its arguments to this method
+     * and provides a more convenient interface for catching exceptions in Promise chains.
+     *
+     * @param exception - thrown object, will be coerced into a {@link HoistException}.
+     * @param options - provides further control over how the exception is shown and/or logged.
+     */
+    handleException(exception: unknown, options?: ExceptionHandlerOptions): void;
+    /**
+     * Create a new exception - See {@link Exception}.
+     *
+     * @param src - if a native JS Error, it will be enhanced into a `HoistException` and returned.
+     *      If a plain object, all properties will be set on a new `HoistException`.
+     *      Other inputs will be treated as the `message` of a new `HoistException`.
+     */
+    exception(src: unknown): HoistException;
+    /** Show "about this app" dialog, powered by {@link EnvironmentService}. */
+    showAboutDialog(): void;
+    /** Show a "release notes" dialog, powered by {@link ChangelogService}. */
+    showChangelog(): void;
+    /**
+     * Show a dialog to elicit feedback from the user.
+     * @param message - optional message to preset within the feedback dialog.
+     */
+    showFeedbackDialog({ message }?: {
+        message?: string;
+    }): void;
+    /** Show the impersonation bar to allow an authorized admin to switch between users. */
+    showImpersonationBar(): void;
+    /** Show a dialog to allow the user to view and set app options. */
+    showOptionsDialog(): void;
+    /** Get a reference to a singleton service by camel case name. */
+    getService(name: string): HoistService;
+    /** Get a reference to a singleton service by full class. */
+    getService<T extends HoistService>(cls: HoistServiceClass<T>): T;
+    /**
+     * Install HoistServices on 'XH'.
+     *
+     * This method will create, initialize, and install the provided services classes on `XH`.
+     * All services will be initialized concurrently. To guarantee execution order of service
+     * initialization, make multiple calls to this method with `await`.
+     *
+     * Applications must choose a unique name of the form xxxService to avoid naming collisions.
+     * If naming collisions are detected, an error will be thrown.
+     *
+     * @param serviceClasses - classes extending HoistService
+     */
+    installServicesAsync(...serviceClasses: HoistServiceClass[]): Promise<void>;
+    /**
+     * Get a collection of Models currently 'active' in the app, returned in creation-time order.
+     * This will include all models that have not yet had `destroy()` called on them.
+     */
+    getModels<T extends HoistModel>(selector?: ModelSelector): T[];
+    /** Get the first active model that matches the given selector, or null if none found. */
+    getModel<T extends HoistModel>(selector?: ModelSelector): T;
+    /**
+     * Get the first active model that has been assigned the given testId, or null if none found.
+     * Note that a small subset of models are automatically assigned the testId of their component.
+     * @see InstanceManager.testSupportedModels
+     */
+    getModelByTestId<T extends HoistModel>(testId: string): T;
+    /** All services registered with this application. */
+    getServices(): HoistService[];
+    /** All Stores registered with this application. */
+    getStores(): Store[];
+    /**
+     * Reset user state and then reload the app.
+     * @see HoistAppModel.restoreDefaultsAsync()
+     */
+    restoreDefaultsAsync(): Promise<void>;
+    /**
+     * Helper method to destroy resources safely (e.g. child HoistModels). Will quietly skip args
+     * that are null / undefined or that do not implement destroy().
+     *
+     * @param args - objects to be destroyed. If any argument is an array, each top-level element
+     *      in the array will be destroyed. (Note this is *not* done recursively.)
+     */
+    safeDestroy(...args: (any | any[])[]): void;
+    /**
+     * Generate an ID string, unique within this run of the client application and suitable for
+     * local-to-client uses, such as auto-generated store record identifiers.
+     *
+     * Deliberately *not* intended to be globally unique, suitable for reuse, or to appear as such.
+     */
+    genId(): string;
+    private get acm();
+    private genLoadId;
+    private genTabId;
+}
+/** The app-wide singleton instance. */
+export declare const XH: XHApi;

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

@@ -0,0 +1,71 @@
+import { TEST_ID } from '@xh/hoist/utils/js';
+import { ComponentType, JSX, Key, ReactElement, ReactNode } from 'react';
+import { PlainObject, Thunkable } from './types/Types';
+/**
+ * Alternative format for specifying React Elements in render functions. This type is designed to
+ * provide a well-formatted, declarative, native javascript approach to configuring Elements and
+ * their children. It serves as an alternative to JSX and is especially useful for code-heavy
+ * element trees. (For element trees with a significant amount of hypertext, JSX could be a better
+ * choice.)
+ *
+ * The core enhancement to this format over jsx is it expects child elements and props to be
+ * specified in a single bundle, with children placed within an `item` or `items` key. This allows
+ * developers to write declarative, multi-level element trees in a concise yet highly-readable
+ * style.  An additional feature is the minor-but-useful support for an `omit` property, which
+ * allows element subtrees to be declaratively excluded from rendering if a given condition is met.
+ * This avoids the need for the common, but clunky React practice of wrapping elements in ternary
+ * statements to accomplish conditional rendering.
+ *
+ * @see {@link createElement} - That function is a thin-wrapper over `React.createChildren` that
+ * consumes this format.
+ *
+ * Finally, note that if a React Component has its own props of `item`, `items`, or `omit`, the
+ * props may be specified in this object with a `$` prefix (e.g. `$item`) to avoid conflicting
+ * with this API.  The '$' will be stripped from the prop name before passing it along to the
+ * underlying component.
+ */
+export type ElementSpec<P> = Omit<P, 'items' | 'item' | 'omit'> & {
+    /** Child Element(s). Equivalent provided as Rest Arguments to React.createElement.*/
+    items?: ReactNode;
+    /**  Equivalent to `items`, offered for code clarity when only one child is needed. */
+    item?: ReactNode;
+    /** True to exclude the Element. */
+    omit?: Thunkable<boolean>;
+    /** React key for this component. */
+    key?: Key;
+    /**
+     * Supports passing a "data-testid" prop to built-in tags (e.g. `div`), to be rendered as an
+     * HTML attribute. See {@link TestSupportProps} for the higher-level `testId` prop that most
+     * Hoist components accept and should use.
+     */
+    [TEST_ID]?: string;
+    $items?: 'items' extends keyof P ? P['items'] : never;
+    $item?: 'item' extends keyof P ? P['item'] : never;
+    $omit?: 'omit' extends keyof P ? P['omit'] : never;
+};
+/**
+ * Union type of all known React Component types supported by Hoist.
+ */
+export type ReactComponent = ComponentType | keyof JSX.IntrinsicElements;
+/**
+ * Factory function that can create a ReactElement from an ElementSpec or children.
+ * Hoist alternative to JSX.
+ */
+export type ElementFactory<P = any> = ((arg: ElementSpec<P>) => ReactElement<P, any>) & ((...args: ReactNode[]) => ReactElement<P, any>);
+/**
+ * Create a React Element from a Component type and an ElementSpec.
+ *
+ * This function is a thin-wrapper over `React.createChildren` that
+ * consumes the ElementSpec format.
+ *
+ * @param component - React Component or string representing an HTML element.
+ * @param spec - element spec.
+ */
+export declare function createElement<C extends ReactComponent>(component: C, spec: ElementSpec<PropType<C>>): ReactElement<PropType<C>, C>;
+/**
+ *  Create a factory function that can create a ReactElement from an ElementSpec or list of children.
+ */
+export declare function elementFactory<C extends ReactComponent>(component: C): ElementFactory<PropType<C>>;
+export declare function elementFactory<P extends PlainObject>(component: ReactComponent): ElementFactory<P>;
+type PropType<C> = C extends ComponentType<infer P> ? P : C extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[C] : any;
+export {};

package/build/types/core/enums/RefreshMode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Options for how content should be refreshed via their built-in RefreshContextModel when they
+ * receive a refresh request while inactive/hidden or are (re)activated by their parent container.
+ * Used by {@link TabContainerModel} and {@link DashContainerModel}.
+ */
+export declare const RefreshMode: Readonly<{
+    /** Always refresh a tab when requested, even if it is inactive (hidden). */
+    ALWAYS: "always";
+    /** Note a refresh request for an inactive tab and run refresh if/when tab is next activated. */
+    ON_SHOW_LAZY: "onShowLazy";
+    /** Always refresh when tab is activated, regardless of whether or not refresh was requested. */
+    ON_SHOW_ALWAYS: "onShowAlways";
+    /** Ignore refresh requests entirely when tab is inactive. Do not auto-refresh when reactivated. */
+    SKIP_HIDDEN: "skipHidden";
+}>;
+export type RefreshMode = (typeof RefreshMode)[keyof typeof RefreshMode];

package/build/types/core/enums/RenderMode.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Options for how contents should be rendered by their parent container.
+ * Used by {@link TabContainerModel}, {@link DashContainerModel}, {@link PanelModel}, and
+ * {@link CardModel}.
+ */
+export declare const RenderMode: Readonly<{
+    /** Always render contents when the parent container is rendered, even if inactive. */
+    ALWAYS: "always";
+    /** Render contents lazily or "just in time" - only if/when the content is first activated. */
+    LAZY: "lazy";
+    /** Render lazily, and actively unmount the contents if/when de-activated. */
+    UNMOUNT_ON_HIDE: "unmountOnHide";
+}>;
+export type RenderMode = (typeof RenderMode)[keyof typeof RenderMode];

package/build/types/core/enums/SizingMode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Standardized sizes used by Grid - affects padding, row heights, font sizes, etc.
+ */
+export declare const SizingMode: Readonly<{
+    TINY: "tiny";
+    COMPACT: "compact";
+    STANDARD: "standard";
+    LARGE: "large";
+}>;
+export type SizingMode = (typeof SizingMode)[keyof typeof SizingMode];

package/build/types/core/impl/InstallServices.d.ts

@@ -0,0 +1,18 @@
+import { HoistServiceClass, Some } from '@xh/hoist/core';
+/**
+ * Install HoistServices on XH.
+ *
+ * @param serviceClasses - Classes extending HoistService
+ *
+ * This method will create, initialize, and install the services classes listed on XH.
+ * All services will be initialized concurrently. To guarantee execution order of service
+ * initialization, make multiple calls to this method with await.
+ *
+ * The created service will also be set on the 'instance' property of its own class.
+ *
+ * Applications must choose a unique name of the form xxxService to avoid naming collisions on
+ * the target. If naming collisions are detected, an error will be thrown.
+ *
+ * @internal - apps should use {@link XH.installServicesAsync} instead.
+ */
+export declare function installServicesAsync(serviceClasses: Some<HoistServiceClass>): Promise<void>;