@xh/hoist 82.0.1 → 82.0.2

package/build/types/desktop/cmp/dash/container/DashContainer.d.ts

@@ -0,0 +1,8 @@
+import { HoistProps, TestSupportProps } from '@xh/hoist/core';
+import './DashContainer.scss';
+import { DashContainerModel } from './DashContainerModel';
+export type DashContainerProps = HoistProps<DashContainerModel> & TestSupportProps;
+/**
+ * Display a set of child components in accordance with a DashContainerModel.
+ */
+export declare const DashContainer: import("react").FC<DashContainerProps>, dashContainer: import("@xh/hoist/core").ElementFactory<DashContainerProps>;

package/build/types/desktop/cmp/dash/container/DashContainerModel.d.ts

@@ -0,0 +1,162 @@
+import { Persistable, PersistableState, PlainObject, RefreshMode, RenderMode, TaskObserver } from '@xh/hoist/core';
+import { DashContainerViewModel } from '@xh/hoist/desktop/cmp/dash/container/DashContainerViewModel';
+import { GoldenLayout } from '@xh/hoist/kit/golden-layout';
+import { DashConfig, DashModel } from '../';
+import { DashContainerViewSpec } from './DashContainerViewSpec';
+export interface DashContainerConfig extends DashConfig<DashContainerViewSpec, DashContainerViewState> {
+    /** Strategy for rendering DashContainerViews. Can also be set per-view in `viewSpecs`*/
+    renderMode?: RenderMode;
+    /** Strategy for refreshing DashContainerViews. Can also be set per-view in `viewSpecs`*/
+    refreshMode?: RefreshMode;
+    /** True to include a button in each stack header showing the dash context menu. */
+    showMenuButton?: boolean;
+    /** Between items in pixels. */
+    margin?: number;
+    /**
+     * Custom settings to be passed to the GoldenLayout instance.
+     * @see http://golden-layout.com/docs/Config.html
+     */
+    goldenLayoutSettings?: PlainObject;
+}
+export interface DashContainerViewState {
+    type: 'row' | 'column' | 'stack' | 'view';
+    id?: string;
+    content?: DashContainerViewState[];
+    title?: string;
+    width?: number | string;
+    height?: number | string;
+    state?: PlainObject;
+}
+/**
+ * Model for a DashContainer, representing its contents and layout state.
+ *
+ * This model provides support for managing dash views, adding new views on the fly,
+ * and tracking / loading state.
+ *
+ * State should be structured as nested arrays of container objects, according to
+ * GoldenLayout's content config. Supported container types are `row`, `column` and `stack`.
+ * Child containers and views should be provided as an array under the `content` key.
+ *
+ *      + `row` lay out its children horizontally.
+ *      + `column` lays out its children vertically.
+ *      + `stack` lays out its children as tabs. `stacks` can only contain `views` (more below)
+ *
+ * The children of `row` and `column` containers can be sized by providing width or height values.
+ * Numeric values represent relative sizes, expressed as a percentage of the available space.
+ * Pixel values can be provided as a string (e.g. '100px'), which will be converted to a relative
+ * size at parse time. Any unaccounted for space will be divided equally across the remaining children.
+ *
+ * We differ from GoldenLayout by offering a new type `view`. These should be configured as
+ * id references to the provided DashContainerViewSpec, e.g. `{type: `view`, id: ViewSpec.id}`.
+ * Use instead of the `component` and `react-component` types provided by GoldenLayout.
+ *
+ * Note that loading state will destroy and reinitialize all components - do so sparingly!
+ *
+ * @example
+ * ```
+ * [{
+ *     type: 'row',
+ *     content: [
+ *          // The first child of this row has pixel width of '200px'.
+ *          // The column will take the remaining width.
+ *         {
+ *             type: 'stack',
+ *             width: '200px',
+ *             content: [
+ *                 {type: 'view', id: 'viewId'},
+ *                 {type: 'view', id: 'viewId'}
+ *             ]
+ *         },
+ *         {
+ *             type: 'column',
+ *             content: [
+ *                 // Relative height of 40%. The remaining 60% will be split equally by the other views.
+ *                 {type: 'view', id: 'viewId', height: 40},
+ *                 {type: 'view', id: 'viewId'},
+ *                 {type: 'view', id: 'viewId'}
+ *             ]
+ *         }
+ *     ]
+ * }]
+ * ```
+ *
+ * @see http://golden-layout.com/docs/ItemConfig.html
+ * @see http://golden-layout.com/tutorials/getting-started-react.html
+ */
+export declare class DashContainerModel extends DashModel<DashContainerViewSpec, DashContainerViewState, DashContainerViewModel> implements Persistable<{
+    state: DashContainerViewState[];
+}> {
+    showMenuButton: boolean;
+    renderMode: RenderMode;
+    refreshMode: RefreshMode;
+    goldenLayoutSettings: PlainObject;
+    margin: number;
+    get isEmpty(): boolean;
+    goldenLayout: GoldenLayout;
+    containerRef: import("react").RefObject<HTMLElement> & import("react").RefCallback<HTMLElement>;
+    loadingStateTask: TaskObserver;
+    private isDestroyingGoldenLayout;
+    constructor({ viewSpecs, viewSpecDefaults, initialState, renderMode, refreshMode, layoutLocked, contentLocked, renameLocked, showMenuButton, margin, goldenLayoutSettings, persistWith, emptyText, addViewButtonText, extraMenuItems }: DashContainerConfig);
+    /**
+     * Restore the initial state as specified by the application at construction time. This is the
+     * state without any persisted state or user changes applied.
+     *
+     * This method will clear the persistent state saved for this component, if any.
+     */
+    restoreDefaultsAsync(): Promise<void>;
+    /** Load state into the DashContainer, recreating its layout and contents */
+    loadStateAsync(state: DashContainerViewState[]): Promise<void>;
+    /**
+     * Add a view to the container.
+     *
+     * @param specId - DashContainerViewSpec id to add to the container
+     * @param container - GoldenLayout container to add it to. If not provided, will be added to the root container.
+     * @param index - An optional index that determines at which position the new item should be added.
+     */
+    addView(specId: string, container?: any, index?: number): void;
+    /**
+     * Remove a view from the container.
+     * @param id - DashContainerViewModel id to remove from the container
+     */
+    removeView(id: string): void;
+    /**
+     * Initiate field renaming for a given view
+     * @param id - DashContainerViewModel id to rename
+     */
+    renameView(id: string): void;
+    onResize(): void;
+    getViewSpec(id: string): DashContainerViewSpec;
+    getViewModel(id: string): DashContainerViewModel;
+    getPersistableState(): PersistableState<{
+        state: DashContainerViewState[];
+    }>;
+    setPersistableState(persistableState: PersistableState<{
+        state: DashContainerViewState[];
+    }>): void;
+    private updateState;
+    private publishState;
+    private onItemDestroyed;
+    private getItems;
+    private getItemsBySpecId;
+    private getItemByViewModel;
+    get viewState(): {};
+    private addViewModel;
+    private removeViewModel;
+    private onStackCreated;
+    private showContextMenu;
+    private refreshActiveViews;
+    private onStackActiveItemChange;
+    private updateTabHeaders;
+    private insertTitleForm;
+    private showTitleForm;
+    private hideTitleForm;
+    private createGoldenLayout;
+    private getTitleElement;
+    /**
+     * Generate and assign viewModelIds to each view in the provided state.
+     * Mutates existingIds to track used IDs.
+     */
+    private withIds;
+    private destroyGoldenLayout;
+    destroy(): void;
+}

package/build/types/desktop/cmp/dash/container/DashContainerViewModel.d.ts

@@ -0,0 +1,14 @@
+import { DashContainerViewSpec, DashViewModel } from '@xh/hoist/desktop/cmp/dash';
+import { DashViewConfig } from '../DashViewModel';
+/**
+ * Model for a content item within a DashContainer.
+ */
+export declare class DashContainerViewModel extends DashViewModel<DashContainerViewSpec> {
+    hostNode: HTMLElement;
+    constructor(cfg: DashViewConfig<DashContainerViewSpec>);
+    destroy(): void;
+    /**
+     * @returns Empty div set to inherit all styling from its parent
+     */
+    private createHostNode;
+}

package/build/types/desktop/cmp/dash/container/DashContainerViewSpec.d.ts

@@ -0,0 +1,17 @@
+import { DashViewSpec } from '@xh/hoist/desktop/cmp/dash/DashViewSpec';
+import { RefreshMode, RenderMode } from '@xh/hoist/core';
+/**
+ * Spec used to generate DashContainerViews and DashContainerViewModels.
+ */
+export interface DashContainerViewSpec extends DashViewSpec {
+    /**
+     *  Strategy for rendering this DashContainerView. If null, will default to its container's
+     *  mode. See enum for description of supported modes.
+     */
+    renderMode?: RenderMode;
+    /**
+     * Strategy for refreshing this DashView. If null, will default to its container's mode.
+     * See enum for description of supported modes.
+     */
+    refreshMode?: RefreshMode;
+}

package/build/types/desktop/cmp/dash/container/impl/DashContainerContextMenu.d.ts

@@ -0,0 +1,15 @@
+import { DashContainerModel } from '../DashContainerModel';
+/**
+ * Context menu for title bar/tabs of a stack in a DashContainer.
+ *
+ * Available view specs are listed in their defined order, optionally
+ * grouped by their `groupName` property
+ *
+ * @internal
+ */
+export declare const dashContainerContextMenu: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;
+/**
+ * 'Add View' menu button to display in an empty DashContainer.
+ * @internal
+ */
+export declare const dashContainerAddViewButton: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<DashContainerModel>>;

package/build/types/desktop/cmp/dash/container/impl/DashContainerMenuButton.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Button and popover for displaying the context menu. Apps can control whether this button is
+ * displayed via DashContainerModel's `showMenuButton` config.
+ *
+ * @internal
+ */
+export declare const dashContainerMenuButton: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;

package/build/types/desktop/cmp/dash/container/impl/DashContainerUtils.d.ts

@@ -0,0 +1,16 @@
+import { DashContainerModel } from '@xh/hoist/desktop/cmp/dash';
+import { DashContainerViewSpec } from '../DashContainerViewSpec';
+import GoldenLayout from 'golden-layout';
+/**
+ * Lookup the DashViewModel id of a rendered view
+ */
+export declare function getViewModelId(view: any): any;
+/**
+ * Convert the output from Golden Layouts into our serializable state
+ */
+export declare function convertGLToState(goldenLayout: GoldenLayout, dashContainerModel: DashContainerModel): any[];
+/**
+ * Convert our serializable state into GoldenLayout config
+ */
+export declare function convertStateToGL(state: any[], dashContainerModel: DashContainerModel): any;
+export declare function goldenLayoutConfig(spec: DashContainerViewSpec, viewModelId: string): any;

package/build/types/desktop/cmp/dash/container/impl/DashContainerView.d.ts

@@ -0,0 +1,12 @@
+import { DashContainerViewModel } from '../DashContainerViewModel';
+/**
+ * Implementation component to show an item within a DashContainer.  This component
+ * is used by DashContainer's internal implementation to:
+ *
+ *   - Mount/unmount its contents according to `DashViewSpec.renderMode`.
+ *   - Track and trigger refreshes according to `DashViewSpec.refreshMode`.
+ *   - Stretch its contents using a flex layout.
+ *
+ * @internal
+ */
+export declare const dashContainerView: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<DashContainerViewModel>>;

package/build/types/desktop/cmp/dash/index.d.ts

@@ -0,0 +1,12 @@
+export * from './DashConfig';
+export * from './DashModel';
+export * from './DashViewModel';
+export * from './DashViewSpec';
+export * from './container/DashContainer';
+export * from './container/DashContainerModel';
+export * from './container/DashContainerViewSpec';
+export * from './canvas/DashCanvas';
+export * from './canvas/DashCanvasModel';
+export * from './canvas/DashCanvasViewModel';
+export * from './canvas/DashCanvasViewSpec';
+export * from './canvas/widgetchooser/DashCanvasWidgetChooser';

package/build/types/desktop/cmp/dock/DockContainer.d.ts

@@ -0,0 +1,25 @@
+import { HoistProps } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { DockContainerModel } from './DockContainerModel';
+export interface DockContainerProps extends HoistProps<DockContainerModel> {
+    /** True to style docked headers with reduced padding and font-size. */
+    compactHeaders?: boolean;
+}
+/**
+ * DockContainer provides a user-friendly way to render multiple child components "docked" to its
+ * bottom edge. Each view is rendered with a configurable header and controls to allow the user to
+ * expand it, collapse it, or optionally "pop it out" into a modal dialog.
+ *
+ * This mirrors the behavior of the familiar Gmail "compose" window and is intended for similar
+ * use-cases such as detail panels and forms, where the user might wish to open multiple children
+ * in a non-modal and unobtrusive manner.
+ *
+ * Docked views are sized according to their content. It is recommended to provide the docked
+ * content with a fixed size.
+ *
+ * DockContainerModel configures all aspects of this container, including its views. See that class
+ * for more details.
+ *
+ * @see DockContainerModel
+ */
+export declare const DockContainer: import("react").FC<DockContainerProps>, dockContainer: import("@xh/hoist/core").ElementFactory<DockContainerProps>;

package/build/types/desktop/cmp/dock/DockContainerModel.d.ts

@@ -0,0 +1,33 @@
+import { HoistModel, RefreshMode, RenderMode } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { DockViewModel, DockViewConfig } from './DockViewModel';
+interface DockContainerConfig {
+    /** DockViewModel configs to be displayed. */
+    views?: DockViewConfig[];
+    /** Direction in which docked views build up as they are added to the container. */
+    direction?: DockViewDirection;
+    /** Strategy for rendering DockViews. Can also be set per-view via `DockViewModelConfig.renderMode` */
+    renderMode?: RenderMode;
+    /** Strategy for refreshing DockViews. Can also be set per-view via `DockViewModelConfig.refreshMode` */
+    refreshMode?: RefreshMode;
+}
+/**
+ * Model for a DockContainer, representing its contents.
+ *
+ * This object provides support for managing docked views, adding new views on the fly,
+ * and expanding / collapsing views programmatically.
+ */
+export declare class DockContainerModel extends HoistModel {
+    views: DockViewModel[];
+    direction: DockViewDirection;
+    renderMode: RenderMode;
+    refreshMode: RefreshMode;
+    constructor({ views, direction, renderMode, refreshMode }?: DockContainerConfig);
+    getView(id: string): DockViewModel;
+    addView(cfg: DockViewConfig): void;
+    removeView(id: string): void;
+    expandView(id: string): void;
+    collapseView(id: string): void;
+}
+type DockViewDirection = 'ltr' | 'rtl';
+export {};

package/build/types/desktop/cmp/dock/DockViewModel.d.ts

@@ -0,0 +1,83 @@
+import { Content, Thunkable, HoistModel, RefreshContextModel, RefreshMode, RenderMode, Awaitable } from '@xh/hoist/core';
+import { ModalSupportModel } from '@xh/hoist/desktop/cmp/modalsupport/ModalSupportModel';
+import '@xh/hoist/desktop/register';
+import { ReactElement } from 'react';
+import { DockContainerModel } from './DockContainerModel';
+export interface DockViewConfig {
+    /** Unique identifier for this DockViewModel. */
+    id: string;
+    /** Parent DockContainerModel. Provided by the container when constructing the model - no need to specify manually. */
+    containerModel?: DockContainerModel;
+    /** Title text added to the header. */
+    title?: string;
+    /** An icon placed at the left-side of the header. */
+    icon?: ReactElement;
+    /** Content to be rendered by this DockView. */
+    content: Content;
+    /** Width: if not set, will be determined by content. */
+    width?: string | number;
+    /** Height: if not set, will be determined by content. */
+    height?: string | number;
+    /** Width of collapsed header. If not set, width will be determined by the length of the title. */
+    collapsedWidth?: string | number;
+    /** Width when displayed in a modal dialog.  If not set, will fall back on default `width`. */
+    dialogWidth?: string | number;
+    /** Height when displayed in a modal dialog.  If not set, will fall back on default `height`. */
+    dialogHeight?: string | number;
+    /** Strategy for rendering this DockView. If null, will default to its container's mode. */
+    renderMode?: RenderMode;
+    /** Strategy for refreshing this DockView. If null, will default to its container's mode. */
+    refreshMode?: RefreshMode;
+    /** true to exclude this DockView.  */
+    omit?: Thunkable<boolean>;
+    /** true (default) to initialise in dock, false to use Dialog. Respects allowDialog. */
+    docked?: boolean;
+    /** true to initialise collapsed, false (default) for expanded. */
+    collapsed?: boolean;
+    /** true (default) to allow removing from the dock entirely. */
+    allowClose?: boolean;
+    /** true (default) to allow popping out of the dock and displaying in a modal Dialog. */
+    allowDialog?: boolean;
+    /** Awaitable callback invoked on close. Return false to prevent close. */
+    onClose?: () => Awaitable<boolean | void>;
+}
+/**
+ * Model for a DockView within a DockContainer. Specifies the actual content (child component)
+ * to be rendered within the view and manages that content's collapsed and docked state.
+ *
+ * This model is not typically created directly within applications. Instead, specify a
+ * configuration for it via the `DockContainerModel.views` constructor config or via
+ * the `DockContainerModel.addView()` method.
+ */
+export declare class DockViewModel extends HoistModel {
+    id: string;
+    title: string;
+    icon: ReactElement;
+    docked: boolean;
+    collapsed: boolean;
+    content: Content;
+    width: string | number;
+    height: string | number;
+    collapsedWidth: string | number;
+    dialogWidth: string | number;
+    dialogHeight: string | number;
+    allowClose: boolean;
+    allowDialog: boolean;
+    onClose?: () => Awaitable<boolean | void>;
+    containerModel: DockContainerModel;
+    refreshContextModel: RefreshContextModel;
+    modalSupportModel: ModalSupportModel;
+    private _renderMode;
+    private _refreshMode;
+    get isActive(): boolean;
+    get renderMode(): RenderMode;
+    get refreshMode(): RefreshMode;
+    constructor({ id, containerModel, title, icon, content, width, height, collapsedWidth, dialogWidth, dialogHeight, refreshMode, renderMode, docked, collapsed, allowClose, allowDialog, onClose }: DockViewConfig);
+    toggleDocked(): void;
+    showInDialog(): void;
+    showInDock(): void;
+    toggleCollapsed(): void;
+    expand(): void;
+    collapse(): void;
+    close(): void;
+}

package/build/types/desktop/cmp/dock/impl/DockContainer.d.ts

@@ -0,0 +1,9 @@
+import '@xh/hoist/desktop/register';
+import './Dock.scss';
+import { DockContainerProps } from '../DockContainer';
+/**
+ * Desktop implementation of DockContainer.
+ *
+ * @internal
+ */
+export declare function dockContainerImpl({ model, className, compactHeaders, ...props }: DockContainerProps, ref: any): import("react").ReactElement<import("@xh/hoist/cmp/layout").BoxComponentProps, any>;

package/build/types/desktop/cmp/dock/impl/DockView.d.ts

@@ -0,0 +1,15 @@
+import { DockViewModel } from '@xh/hoist/desktop/cmp/dock';
+import { HoistProps } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import './Dock.scss';
+interface DockViewProps extends HoistProps<DockViewModel> {
+    /** True to style docked headers with reduced padding and font-size. */
+    compactHeaders?: boolean;
+}
+/**
+ * Wrapper for contents to be shown within a DockContainer.
+ *
+ * @internal
+ */
+export declare const dockView: import("@xh/hoist/core").ElementFactory<DockViewProps>;
+export {};

package/build/types/desktop/cmp/dock/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DockContainer';
+export * from './DockContainerModel';
+export * from './DockViewModel';

package/build/types/desktop/cmp/error/impl/ErrorMessage.d.ts

@@ -0,0 +1,7 @@
+import { ErrorMessageProps } from '@xh/hoist/cmp/error';
+import '@xh/hoist/desktop/register';
+/**
+ * Desktop implementation of ErrorMessage.
+ * @internal
+ */
+export declare const errorMessageImpl: import("@xh/hoist/core").ElementFactory<Omit<ErrorMessageProps, "error" | "actionFn" | "detailsFn">>;

package/build/types/desktop/cmp/filechooser/FileChooser.d.ts

@@ -0,0 +1,42 @@
+import { BoxProps, HoistProps, Some } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ReactNode } from 'react';
+import './FileChooser.scss';
+import { FileChooserModel } from './FileChooserModel';
+export interface FileChooserProps extends HoistProps<FileChooserModel>, BoxProps {
+    /** File type(s) to accept (e.g. `['.doc', '.docx', '.pdf']`). */
+    accept?: Some<string>;
+    /** True (default) to allow multiple files in a single upload. */
+    enableMulti?: boolean;
+    /**
+     * True to allow user to drop multiple files into the dropzone at once.  True also allows
+     * for selection of multiple files within the OS pop-up window.  Defaults to enableMulti.
+     */
+    enableAddMulti?: boolean;
+    /** Maximum accepted file size in bytes. */
+    maxSize?: number;
+    /** Minimum accepted file size in bytes. */
+    minSize?: number;
+    /**
+     * True (default) to display the selected file(s) in a grid alongside the dropzone. Note
+     * that, if false, the component will not provide any built-in indication of its selection.
+     */
+    showFileGrid?: boolean;
+    /** Intro/help text to display within the dropzone target. */
+    targetText?: ReactNode;
+}
+/**
+ * A component to select one or more files from the local filesystem. Wraps the third-party
+ * react-dropzone component to provide both drag-and-drop and click-to-browse file selection.
+ * Expands upon this core functionality with an optional grid (enabled by default) displaying
+ * the list of selected files and allowing the user to remove files from the selection.
+ *
+ * This component should be provided with a FileChooserModel instance, as the model holds an
+ * observable collection of File objects and provides a public API to manipulate the selection.
+ *
+ * The application is responsible for processing the selected files (e.g. by uploading them to a
+ * server) and clearing the selection when complete.
+ *
+ * @see FileChooserModel
+ */
+export declare const FileChooser: import("react").FC<FileChooserProps>, fileChooser: import("@xh/hoist/core").ElementFactory<FileChooserProps>;

package/build/types/desktop/cmp/filechooser/FileChooserModel.d.ts

@@ -0,0 +1,23 @@
+import { GridModel } from '@xh/hoist/cmp/grid';
+import { HoistModel } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+export declare class FileChooserModel extends HoistModel {
+    files: File[];
+    lastRejectedCount: number;
+    gridModel: GridModel;
+    constructor();
+    /**
+     * Add Files to the selection. Typically called by the component's embedded react-dropzone.
+     * Files will be de-duplicated by name, with a newly added file taking precedence over any
+     * existing file with the same name.
+     */
+    addFiles(filesToAdd: File[]): void;
+    setSingleFile(file: File): void;
+    /** Remove a single file from the current selection. */
+    removeFileByName(name: string): void;
+    /** Clear the current selection. */
+    clear(): void;
+    private createGridModel;
+    onDrop(accepted: any, rejected: any, enableMulti: any): void;
+    onFilesChange(files: any): void;
+}

package/build/types/desktop/cmp/filechooser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FileChooser';
+export * from './FileChooserModel';

package/build/types/desktop/cmp/filter/FilterChooser.d.ts

@@ -0,0 +1,32 @@
+import { FilterChooserModel } from '@xh/hoist/cmp/filter';
+import { HoistProps, LayoutProps } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ReactElement } from 'react';
+import './FilterChooser.scss';
+export interface FilterChooserProps extends HoistProps<FilterChooserModel>, LayoutProps {
+    /** True to focus the control on render. */
+    autoFocus?: boolean;
+    /** True to disable user interaction. */
+    disabled?: boolean;
+    /** True to show a "clear" button at the right of the control.  Defaults to true. */
+    enableClear?: boolean;
+    /** True to show count of filter tags next to the left icon. */
+    displayCount?: boolean;
+    /** Icon to display inline on the left side of the input. */
+    leftIcon?: ReactElement;
+    /** Max-height of dropdown. Either a number in pixels or a valid CSS string, such as '80vh'. */
+    maxMenuHeight?: number | string;
+    /** Placement of the dropdown menu relative to the input control. */
+    menuPlacement?: 'auto' | 'top' | 'bottom';
+    /** Width in pixels for the dropdown menu - if unspecified, defaults to control width. */
+    menuWidth?: number;
+    /** Text to display when control is empty. */
+    placeholder?: string;
+    /** Icon clicked to launch favorites menu. (Defaults to Icon.favorite()) */
+    favoritesIcon?: ReactElement;
+}
+/**
+ * A Select based control for searching and choosing filters.
+ * @see FilterChooserModel
+ */
+export declare const FilterChooser: import("react").FC<FilterChooserProps>, filterChooser: import("@xh/hoist/core").ElementFactory<FilterChooserProps>;

package/build/types/desktop/cmp/filter/PopoverFilterChooser.d.ts

@@ -0,0 +1,9 @@
+import '@xh/hoist/desktop/register';
+import './PopoverFilterChooser.scss';
+import { FilterChooserProps } from './FilterChooser';
+/**
+ * A wrapper around a FilterChooser that renders in a popover when opened, allowing it to expand
+ * vertically beyond the height of a toolbar.
+ * @see FilterChooser
+ */
+export declare const PopoverFilterChooser: import("react").FC<FilterChooserProps>, popoverFilterChooser: import("@xh/hoist/core").ElementFactory<FilterChooserProps>;

package/build/types/desktop/cmp/filter/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FilterChooser';
+export * from './PopoverFilterChooser';
+export * from '@xh/hoist/cmp/filter';

package/build/types/desktop/cmp/form/FormField.d.ts

@@ -0,0 +1,64 @@
+import { PopoverPosition, PopperBoundary } from '@blueprintjs/core';
+import { BaseFormFieldProps } from '@xh/hoist/cmp/form';
+import { HSide } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ReactNode } from 'react';
+import './FormField.scss';
+export interface FormFieldProps extends BaseFormFieldProps {
+    /**
+     * Focus or toggle input when label is clicked.
+     * Defaulted from containing Form, or true.
+     */
+    clickableLabel?: boolean;
+    /**
+     * Layout field inline with label to the left.
+     * Defaulted from containing Form, or false.
+     */
+    inline?: boolean;
+    /** Alignment of label text, default 'left'. */
+    labelTextAlign?: HSide;
+    /** Width of the label in pixels. */
+    labelWidth?: number;
+    /**
+     * Signal a validation error by inserting a warning glyph in the far left side of the
+     * Input, if supported. (Currently TextField and NumberInput only.)
+     * Defaulted from containing Form, or false.
+     */
+    leftErrorIcon?: boolean;
+    /**
+     * Display validation messages in a tooltip, as opposed to inline within the component.
+     * Defaulted from containing Form, or false.
+     */
+    minimal?: boolean;
+    /**
+     * Minimal validation tooltip will try to fit within the corresponding boundary.
+     * @see https://blueprintjs.com/docs/#core/components/popover
+     */
+    tooltipBoundary?: PopperBoundary;
+    /**
+     * Position for minimal validation tooltip.
+     * @see https://blueprintjs.com/docs/#core/components/popover
+     */
+    tooltipPosition?: PopoverPosition;
+}
+/**
+ * Standardised wrapper around a HoistInput component for use in a form. FormField provides
+ * consistent layout, labelling, and optional display of validation messages for the field.
+ * FormField also supports an alternative read-only display of the bound data.
+ *
+ * This component is intended to be used within a `Form` component and bound to a 'FieldModel'
+ * within that Form's backing `FormModel`. FormField will set up the binding between its input and the
+ * FieldModel instance and can display validation messages, switch between read-only and disabled
+ * variants of its child, and source default props via the parent Form's `fieldDefaults` prop.
+ *
+ * This component is designed to work with an instance of `HoistInput` as its input, and makes use
+ * of many of HoistInput's props. For best results with a customized input, consider wrapping a
+ * HoistInput and passing all props along to it.   At the very least, all custom inputs
+ * must accept 'model' and 'bind' props in order to show and edit data.
+ *
+ * FormFields can be sized and otherwise customized via standard layout props. They will
+ * adjust their child inputs to fill their available space (if appropriate given the input type),
+ * so the recommended approach is to specify any sizing on the FormField (as opposed to the input).
+ */
+export declare const FormField: import("react").FC<FormFieldProps>, formField: import("@xh/hoist/core").ElementFactory<FormFieldProps>;
+export declare function defaultReadonlyRenderer(value: any): ReactNode;

package/build/types/desktop/cmp/form/index.d.ts

@@ -0,0 +1 @@
+export * from './FormField';