@xh/hoist 82.0.1 → 82.0.3

package/build/types/cmp/treemap/TreeMapModel.d.ts

@@ -0,0 +1,181 @@
+import { HoistModel, PlainObject, Theme } from '@xh/hoist/core';
+import { Store, StoreRecord, StoreRecordId } from '@xh/hoist/data';
+import { GridModel } from '@xh/hoist/cmp/grid';
+import { FilterLike } from '@xh/hoist/data/filter/Types';
+import { ReactNode } from 'react';
+/**
+ * Core Model for a TreeMap.
+ *
+ * You should specify the TreeMap's data store, in addition to which StoreRecord fields should be
+ * mapped to label (a node's display name), value (a node's size), and heat (a node's color).
+ *
+ * Can also (optionally) be bound to a GridModel. This will enable selection syncing and
+ * expand / collapse syncing for GridModels in `treeMode`.
+ *
+ * Supports any Highcharts TreeMap algorithm ('squarified', 'sliceAndDice', 'stripes' or 'strip').
+ *
+ * Node colors are normalized to a 0-1 range and mapped to a colorAxis via the following colorModes:
+ * 'linear' distributes normalized color values across the colorAxis according to the heatField.
+ * 'wash' ignores the intensity of the heat value, applying a single positive and negative color.
+ * 'none' will ignore the colorAxis, and instead use the neutral color.
+ *
+ * Color customization can be managed by setting colorAxis stops via the `highchartsConfig`.
+ *
+ * @see https://www.highcharts.com/docs/chart-and-series-types/treemap for Highcharts config options
+ */
+export interface TreeMapConfig {
+    /** A store containing records to be displayed. */
+    store?: Store;
+    /** Optional GridModel to bind to. */
+    gridModel?: GridModel;
+    /** Maximum number of nodes to render. Be aware that increasing this can severely degrade performance. */
+    maxNodes?: number;
+    /**
+     * Maximum number of node labels to attempt to render. Defaults to 250, based on the fact that
+     * the smaller boxes beyond that count are unlikely to be able to have enough room to render
+     * labels in any case. Be aware that increasing this can degrade performance.
+     */
+    maxLabels?: number;
+    /**
+     * Highcharts configuration object for the managed map.
+     * Will be recursively merged into the top-level HC config generated by this model, the component.
+     */
+    highchartsConfig?: PlainObject;
+    /** StoreRecord field to use to determine node label. */
+    labelField?: string;
+    /** StoreRecord field to use to determine node size. */
+    valueField?: string;
+    /** StoreRecord field to use to determine node color. */
+    heatField?: string;
+    /** Renderer to use when displaying value in the default tooltip. Should return HTML. */
+    valueRenderer?: TreeMapValueRendererFn;
+    /** Renderer to use when displaying heat in the default tooltip. Should return HTML. */
+    heatRenderer?: TreeMapHeatRendererFn;
+    /**
+     * Value for providing a clamped, stable upper boundary on heat color intensity.
+     * If not provided, maxHeat will be determined by the dataset on each load.
+     */
+    maxHeat?: number;
+    /** Maximum tree depth to render. */
+    maxDepth?: number;
+    /** Layout algorithm to use. */
+    algorithm?: TreeMapAlgorithm;
+    /** Heat color distribution mode. */
+    colorMode?: TreeMapColorMode;
+    /** Theme to use. Leave undefined to use the global theme. */
+    theme?: Theme;
+    /**
+     * Callback to call when a node is clicked.
+     * If not provided, by default will select a record when using a GridModel.
+     */
+    onClick?: (StoreRecord: any, MouseEvent: any) => void;
+    /**
+     * Callback to call when a node is double-clicked.
+     * If not provided, by default will expand / collapse a record when using a GridModel.
+     */
+    onDoubleClick?: (StoreRecord: any, MouseEvent: any) => void;
+    /** `true` to use the default tooltip renderer, or a custom tooltipFn. */
+    tooltip?: boolean | TreeMapTooltipFn;
+    /** Element/text to render if TreeMap has no records. */
+    emptyText?: ReactNode;
+    /** Data filter to apply to records. */
+    filter?: FilterLike;
+}
+export declare class TreeMapModel extends HoistModel {
+    store: Store;
+    gridModel: GridModel;
+    maxNodes: number;
+    maxLabels: number;
+    valueRenderer: TreeMapValueRendererFn;
+    heatRenderer: TreeMapHeatRendererFn;
+    onClick: (StoreRecord: any, MouseEvent: any) => void;
+    onDoubleClick: (StoreRecord: any, MouseEvent: any) => void;
+    tooltip: boolean | TreeMapTooltipFn;
+    emptyText: ReactNode;
+    highchartsConfig: any;
+    data: TreeMapRecord[];
+    labelField: string;
+    valueField: string;
+    heatField: string;
+    maxHeat: number;
+    maxDepth: number;
+    algorithm: TreeMapAlgorithm;
+    colorMode: TreeMapColorMode;
+    theme: Theme;
+    isMasking: boolean;
+    _filter: any;
+    constructor(config?: TreeMapConfig);
+    get total(): number;
+    get valueFieldLabel(): string;
+    get heatFieldLabel(): string;
+    get selectedIds(): StoreRecordId[];
+    get expandState(): PlainObject;
+    get empty(): boolean;
+    get error(): string;
+    processAndSetData(sourceRecords: any): void;
+    /**
+     * Create a flat list of TreeMapRecords from hierarchical store data, ready to be
+     * passed to HighCharts for rendering. Drilldown children are included according
+     * to the bound GridModel's expandState.
+     */
+    processRecordsRecursive(sourceRecords: any, parentId?: any, depth?: number): Partial<TreeMapRecord>[];
+    /**
+     * Removes node labels if the number of nodes exceeds maxLabels.
+     * This is a performance optimisation to mitigate slow SVG text rendering. Labels are prioritized
+     * according to node size, from largest to smallest, on the basis that removed labels would
+     * likely be hidden due to the size of the node.
+     */
+    limitLabels(data: any): any;
+    /**
+     * Normalizes heatValues to colorValues between 0-1, where 0 is the maximum negative heat,
+     * 1 is the maximum positive heat, and 0.5 is no heat. This allows the colorValue to map to
+     * the colorAxis provided to Highcharts.
+     *
+     * Takes the colorMode into account:
+     * a) 'linear' distributes normalized color values across the colorAxis.
+     * b) 'wash' ignores the intensity of the heat value, applying a flat positive or negative color.
+     * c) 'none' ignores the heat value altogether, coloring all nodes with the neutral color
+     */
+    normaliseColorValues(data: any): any;
+    normalizeToRange(value: any, fromMin: any, fromMax: any, toMin: any, toMax: any): any;
+    valueIsValid(value: any): boolean;
+    nodeIsExpanded(treePath: any): any;
+    toggleNodeExpanded(treePath: any): void;
+    defaultOnClick: (record: any, e: any) => void;
+    defaultOnDoubleClick: (record: any) => void;
+}
+export interface TreeMapRecord {
+    /** StoreRecordId of the StoreRecord from which TreeMapRecord was created. */
+    id: StoreRecordId;
+    /** StoreRecord from which TreeMapRecord was created. */
+    record: StoreRecord;
+    /** Used by Highcharts to determine the node label. */
+    name: string;
+    /** Used by Highcharts to determine the node size. */
+    value: number;
+    /** Transient property used to determine the Highcharts colorValue. */
+    heatValue: number;
+    /** Used by Highcharts to determine the color in a heat map. */
+    colorValue: number;
+    /** StoreRecordId of parent StoreRecord in hierarchical data. */
+    parent?: StoreRecordId;
+}
+/** Layout algorithm to use. */
+export type TreeMapAlgorithm = 'squarified' | 'sliceAndDice' | 'stripes' | 'strip';
+/** Heat color distribution mode. */
+export type TreeMapColorMode = 'linear' | 'wash' | 'none';
+/**
+ * Normalized renderer function to display value in the tree map tooltip.
+ * @returns the formatted value (html) for display.
+ */
+export type TreeMapValueRendererFn = (value: any, record: StoreRecord) => string;
+/**
+ * Normalized renderer function to display heat in the tree map tooltip.
+ * @returns the formatted value (html) for display.
+ */
+export type TreeMapHeatRendererFn = (value: any, record: StoreRecord) => string;
+/**
+ * Normalized renderer function to produce a tree map tooltip.
+ * @returns the formatted value (html) for display.
+ */
+export type TreeMapTooltipFn = (record: StoreRecord) => string;

package/build/types/cmp/treemap/index.d.ts

@@ -0,0 +1,4 @@
+export * from './TreeMap';
+export * from './TreeMapModel';
+export * from './SplitTreeMap';
+export * from './SplitTreeMapModel';

package/build/types/cmp/viewmanager/DataAccess.d.ts

@@ -0,0 +1,28 @@
+import { ViewInfo } from './ViewInfo';
+import { View } from './View';
+import { ViewManagerModel, ViewUserState, ViewUpdateSpec, ViewCreateSpec } from './ViewManagerModel';
+/**
+ * Supporting class for accessing and updating ViewManager and View data.
+ *
+ * @internal
+ */
+export declare class DataAccess<T> {
+    private readonly model;
+    constructor(model: ViewManagerModel<T>);
+    /** Fetch metadata for all views accessible by current user. */
+    fetchDataAsync(): Promise<{
+        views: ViewInfo[];
+        state: ViewUserState;
+    }>;
+    /** Fetch the latest version of a view, or the in-code default if token null/undefined/empty. */
+    fetchViewAsync(token: string): Promise<View<T>>;
+    /** Create a new view, owned by the current user.*/
+    createViewAsync(spec: ViewCreateSpec): Promise<View<T>>;
+    /** Update all aspects of a view's metadata.*/
+    updateViewInfoAsync(view: ViewInfo, updates: ViewUpdateSpec): Promise<View<T>>;
+    /** Update a view's value. */
+    updateViewValueAsync(view: View<T>, value: Partial<T>): Promise<View<T>>;
+    deleteViewsAsync(views: ViewInfo[]): Promise<void>;
+    updateStateAsync(update: Partial<ViewUserState>): Promise<ViewUserState>;
+    private ensureEditable;
+}

package/build/types/cmp/viewmanager/View.d.ts

@@ -0,0 +1,37 @@
+import { PlainObject } from '@xh/hoist/core';
+import { ViewManagerModel } from './ViewManagerModel';
+import { ViewInfo } from './ViewInfo';
+import { JsonBlob } from '@xh/hoist/svc';
+/**
+ * A named saved bundle of state for components.
+ */
+export declare class View<T extends PlainObject = PlainObject> {
+    /**
+     * Default View representing code state of all contained components.
+     * Available for all view managers where `enableDefault` is true.
+     */
+    /** Metadata about this View. Null for 'default' view */
+    readonly info: ViewInfo;
+    /**
+     * State for the components in the view. Only state that differs from the initial "code"
+     * state of the components is captured.
+     */
+    readonly value: Partial<T>;
+    private readonly model;
+    get name(): string;
+    get group(): string;
+    get description(): string;
+    get token(): string;
+    get type(): string;
+    get isDefault(): boolean;
+    get isGlobal(): boolean;
+    get isShared(): boolean;
+    get isOwned(): boolean;
+    get isCurrentView(): boolean;
+    get lastUpdated(): number;
+    get typedName(): string;
+    static fromBlob<T>(blob: JsonBlob, model: ViewManagerModel): View<T>;
+    static createDefault<T>(model: ViewManagerModel): View<T>;
+    withUpdatedValue(value: Partial<T>): View<T>;
+    constructor(info: ViewInfo, value: Partial<T>, model: ViewManagerModel);
+}

package/build/types/cmp/viewmanager/ViewInfo.d.ts

@@ -0,0 +1,55 @@
+import { ViewManagerModel } from './ViewManagerModel';
+import { JsonBlob } from '@xh/hoist/svc';
+import { PlainObject } from '@xh/hoist/core';
+/**
+ * Metadata describing {@link View} managed by {@link ViewManagerModel}.
+ */
+export declare class ViewInfo {
+    /** Unique Id */
+    readonly token: string;
+    /** App-defined type discriminator. */
+    readonly type: string;
+    /** User-supplied descriptive name. */
+    readonly name: string;
+    /** Description of the view. **/
+    readonly description: string;
+    /** User owning this view. Null if the view is global.*/
+    readonly owner: string;
+    /**
+     * True if the owner (which can be the current user) has made this view accessible to all other
+     * users. Note always `false` for global views, to better distinguish the two sharing models.
+     */
+    readonly isShared: boolean;
+    /** True if this view is global and visible to all users. */
+    readonly isGlobal: boolean;
+    /** Optional group name used for bucketing this view in display. */
+    readonly group: string;
+    /**
+     * Original meta-data on views associated JsonBlob.
+     * Not typically used by applications.
+     * @internal
+     */
+    readonly meta: PlainObject;
+    dateCreated: number;
+    lastUpdated: number;
+    lastUpdatedBy: string;
+    readonly model: ViewManagerModel;
+    constructor(blob: JsonBlob, model: ViewManagerModel);
+    get isOwned(): boolean;
+    get isEditable(): boolean;
+    get isCurrentView(): boolean;
+    /**
+     * True if this view should appear on the users easy access menu.
+     *
+     * This value is computed with the user persisted state for the view.
+     *
+     * If the user has not set pinning state for the view, global views and
+     * owned views are pinned by default.
+     */
+    get isPinned(): boolean;
+    /**
+     * The user indicated pin state for this view, or null if user has not indicated a preference.
+     */
+    get isUserPinned(): boolean | null;
+    get typedName(): string;
+}

package/build/types/cmp/viewmanager/ViewManagerModel.d.ts

@@ -0,0 +1,243 @@
+import { HoistModel, LoadSpec, PlainObject, TaskObserver, Thunkable } from '@xh/hoist/core';
+import type { ViewManagerProvider } from '@xh/hoist/core';
+import { ReactNode } from 'react';
+import { ViewInfo } from './ViewInfo';
+import { View } from './View';
+export interface ViewCreateSpec {
+    name: string;
+    group: string;
+    description: string;
+    isShared: boolean;
+    isGlobal: boolean;
+    isPinned?: boolean;
+    value: PlainObject;
+}
+export type ViewUpdateSpec = Partial<Omit<ViewCreateSpec, 'value'>>;
+export interface ViewUserState {
+    currentView?: string;
+    userPinned: Record<string, boolean>;
+    autoSave: boolean;
+}
+export interface ViewManagerConfig {
+    /**
+     * Required discriminator for the particular class of views to be loaded and managed by this
+     * model. Used to set the `type` property on all JSONBlobs persisted by this model.
+     *
+     * Choose something descriptive and specific enough to be identifiable and allow for different
+     * ViewManagers to be added to your app in the future - e.g. `portfolioGridView` or
+     * `tradeBlotterDashboard`.
+     */
+    type: string;
+    /**
+     * Optional user-facing qualifier (default "default") for the special in-code default view
+     * option, if enabled. Will be prepended to `typeDisplayName`.
+     *
+     * A use case is to support a ViewManager persisted Dashboard, where the in-code default is an
+     * empty layout, this config is set to "New", and the `typeDisplayName` is set to "Dashboard".
+     * This results in a "New Dashboard" option in the menu, allowing users to quickly access a
+     * blank dashboard to start building from scratch, while forcing a save-as to persist.
+     */
+    defaultDisplayName?: string;
+    /** True (default) to allow users to opt-in to auto-saving changes to their current view. */
+    enableAutoSave?: boolean;
+    /**
+     * True (default) to allow the user to select a special view from the menu that restores all
+     * persisted objects to their in-code defaults. If not enabled, at least one globally shared
+     * view should be added to provide an initial selection for users without any private views.
+     */
+    enableDefault?: boolean;
+    /**
+     * True (default) to enable "global" views - i.e. views that are not owned by a user and are
+     * available to all. At least some users should have `manageGlobal` set to true to allow
+     * creation and management of these views.
+     */
+    enableGlobal?: boolean;
+    /** True (default) to allow users to share their views with other users. */
+    enableSharing?: boolean;
+    /**
+     * User-facing qualifier for labelling globally shared views - default "global". A use case
+     * would be to set to the name of the company/team that manages these canonical views, e.g.
+     * "Acme Corp".
+     */
+    globalDisplayName?: string;
+    /**
+     * Function to determine the initial view for a user, when they have no prior view already
+     * persisted. Called with a list of views available to the current user.
+     *
+     * Must be set when `enableDefault: false`. Developers should take care to return *some* view
+     * in this case, if any are available. If no view is returned, the control will be forced to
+     * fall back to the in-code default.
+     */
+    initialViewSpec?: (views: ViewInfo[]) => ViewInfo;
+    /**
+     * Optional discriminator for the particular area of an app in which this instance of the
+     * ViewManager appears, for apps that have multiple manager instances that load the same `type`
+     * of views. A particular `currentView` and `pendingValue` will be maintained for each instance,
+     * but all other options and the available library of views will be shared across the `type`.
+     */
+    instance?: string;
+    /**
+     * True to allow the user to creat and manage Global views. Apps are expected to commonly set
+     * this based on user roles - e.g. `XH.getUser().hasRole('MANAGE_GRID_VIEWS')`.
+     */
+    manageGlobal?: Thunkable<boolean>;
+    /**
+     * True (default) to save pending state to SessionStorage so that it can be restored across
+     * browser refreshes. Unlike auto-save, this does not write to the database.
+     */
+    preserveUnsavedChanges?: boolean;
+    /**
+     * User-facing display name for the type of views being managed - e.g. "report" or "dashboard".
+     * Displayed in the `ViewManager` menu and associated management dialogs and prompts.
+     * Defaulted from `type` if not provided.
+     */
+    typeDisplayName?: string;
+    /**
+     * Optional render function to customize the BlueprintJS `menuItem` shown for each view in the
+     * ViewManager menu.
+     */
+    viewMenuItemFn?: (view: ViewInfo, model: ViewManagerModel) => ReactNode;
+}
+/**
+ *  ViewManagerModel coordinates the loading, saving, and management of user-defined bundles of
+ *  {@link Persistable} component/model state.
+ *
+ *  - Models to be persisted are bound to this model via their `persistWith` config. One or more
+ *    models can be bound to a single ViewManagerModel, allowing a single view to capture the state
+ *    of multiple components - e.g. grouping and filtering options along with grid state.
+ *  - Views are persisted back to the server as JsonBlob objects.
+ *  - Views can be private to their owner, or optionally enabled for sharing to (all) other users.
+ *  - Views can be marked as pinned for quick access.
+ *  - See the desktop {@link ViewManager} component - the initial Hoist UI for this model.
+ */
+export declare class ViewManagerModel<T = PlainObject> extends HoistModel {
+    /**
+     * Factory to create new instances of this model and await its initial load before binding to
+     * any persistable component models. This ensures that bound models will have the expected
+     * initial persisted state applied within their constructor, before their components have
+     * rendered, and avoids thrashing of component state during initial load.
+     *
+     * To minimize the impact this async requirement has on the design and lifecycle of individual
+     * components within an app, consider eagerly constructing any viewManagerModels required within
+     * your `AppModel.initAsync` method and saving a reference to them there for component models
+     * to then use when they are mounted. The VM model instances will then be "ready to go" and
+     * usable within model constructors. (Initializing and referencing from one or more app
+     * services would be another, similar option.)
+     *
+     * Note that this method may throw if the ViewManager cannot be initialized successfully,
+     * but should generally fail quietly due to the early instantiation.
+     */
+    static createAsync(config: ViewManagerConfig): Promise<ViewManagerModel>;
+    /** Immutable configuration for this model. */
+    readonly type: string;
+    readonly instance: string;
+    readonly typeDisplayName: string;
+    readonly defaultDisplayName: string;
+    readonly globalDisplayName: string;
+    readonly viewMenuItemFn: (view: ViewInfo, model: ViewManagerModel) => ReactNode;
+    readonly enableAutoSave: boolean;
+    readonly enableDefault: boolean;
+    readonly enableGlobal: boolean;
+    readonly enableSharing: boolean;
+    readonly preserveUnsavedChanges: boolean;
+    readonly manageGlobal: boolean;
+    readonly initialViewSpec: (views: ViewInfo[]) => ViewInfo;
+    /** Current view. Will not include uncommitted changes */
+    view: View<T>;
+    /** Loaded saved view library - both private and global */
+    views: ViewInfo[];
+    /**
+     * Map of user's preferred pinned state for views.
+     *
+     * Note that the actual pinned state for the views is determined by this value, layered
+     * over the default state of the views themselves.
+     */
+    userPinned: Record<string, boolean>;
+    /**
+     * True if user has opted-in to automatically saving changes to personal views (if auto-save
+     * generally available as per `enableAutoSave`).
+     */
+    autoSave: boolean;
+    /**
+     * TaskObserver linked to {@link selectViewAsync}. If a change to the active view is likely to
+     * require intensive layout/grid work, consider masking affected components with this task.
+     */
+    selectTask: TaskObserver;
+    /** TaskObserver linked to {@link saveAsync}. */
+    saveTask: TaskObserver;
+    /** Unsaved changes on the current view.*/
+    private pendingValue;
+    /**
+     * Array of {@link ViewManagerProvider} instances bound to this model. Used to proactively push
+     * state to the target components when the model's selected `value` changes.
+     */
+    private providers;
+    /** Data access for persisting views. */
+    private dataAccess;
+    get isValueDirty(): boolean;
+    get isViewSavable(): boolean;
+    get isViewAutoSavable(): boolean;
+    get autoSaveUnavailableReason(): string;
+    get pinnedViews(): ViewInfo[];
+    /** Views owned by me */
+    get ownedViews(): ViewInfo[];
+    /** Views shared *with* me */
+    get sharedViews(): ViewInfo[];
+    /** Global views */
+    get globalViews(): ViewInfo[];
+    /** True if any async tasks are pending. */
+    get isLoading(): boolean;
+    /**
+     * Use the static {@link createAsync} factory to create an instance of this model and await its
+     * initial load before binding to persistable components.
+     */
+    private constructor();
+    doLoadAsync(loadSpec: LoadSpec): Promise<void>;
+    selectViewAsync(view: string | ViewInfo, opts?: {
+        alertUnsavedChanges: boolean;
+    }): Promise<void>;
+    saveAsAsync(spec: ViewCreateSpec): Promise<void>;
+    saveAsync(): Promise<void>;
+    resetAsync(): Promise<void>;
+    getValue(): Partial<T>;
+    setValue(value: Partial<T>): void;
+    userPin(view: ViewInfo): void;
+    userUnpin(view: ViewInfo): void;
+    isUserPinned(view: ViewInfo): boolean | null;
+    /**
+     * Validate a name for a view.
+     * @param name - candidate name to validate
+     * @param existing - existing view that will have the name.  null if the name is for a new view.
+     * @param isGlobal - true if the name is for a global view.
+     */
+    validateViewNameAsync(name: string, existing: ViewInfo, isGlobal: boolean): Promise<string>;
+    /** Update all aspects of a view's metadata.*/
+    updateViewInfoAsync(view: ViewInfo, updates: ViewUpdateSpec): Promise<View<T>>;
+    deleteViewsAsync(toDelete: ViewInfo[]): Promise<void>;
+    /**
+     * Called by {@link ViewManagerProvider} to receive state changes from this model.
+     * @internal
+     */
+    registerProvider(provider: ViewManagerProvider<any>): void;
+    /**
+     * Called by {@link ViewManagerProvider} to stop receiving state changes.
+     * @internal
+     */
+    unregisterProvider(provider: ViewManagerProvider<any>): void;
+    private initAsync;
+    private unsavedChangesReaction;
+    private autoSaveReaction;
+    private stateReactions;
+    private loadViewAsync;
+    private maybeAutoSaveAsync;
+    private setAsView;
+    private handleException;
+    private noteSuccess;
+    private get pendingValueStorageKey();
+    /**
+     * Stringify and parse to ensure that any value set here is valid, serializable JSON.
+     */
+    private cleanState;
+    private confirmDiscardChangesAsync;
+    private maybeConfirmSaveAsync;
+}

package/build/types/cmp/viewmanager/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ViewManagerModel';
+export * from './ViewInfo';
+export * from './View';
+export * from './DataAccess';

package/build/types/cmp/websocket/WebSocketIndicator.d.ts

@@ -0,0 +1,9 @@
+import { BoxProps, HoistProps } from '@xh/hoist/core';
+export interface WebSocketIndicatorProps extends HoistProps, BoxProps {
+    /** True to display status as an icon only, without text label. */
+    iconOnly?: boolean;
+}
+/**
+ * Provides a visual indicator of connection status for @see {@link WebSocketService}.
+ */
+export declare const WebSocketIndicator: import("react").FC<WebSocketIndicatorProps>, webSocketIndicator: import("@xh/hoist/core").ElementFactory<WebSocketIndicatorProps>;

package/build/types/cmp/websocket/index.d.ts

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

package/build/types/cmp/zoneGrid/Types.d.ts

@@ -0,0 +1,35 @@
+import { Column, ColumnRenderer, ColumnSortSpec } from '@xh/hoist/cmp/grid';
+import { PersistOptions } from '@xh/hoist/core';
+export type Zone = 'tl' | 'tr' | 'bl' | 'br';
+export interface ZoneMapping {
+    /** Field to display. Must match a Field found in the Store */
+    field: string;
+    /** True to prefix the field value with its name */
+    showLabel?: boolean;
+}
+export interface ZoneLimit {
+    /** Min number of fields that should be mapped to the zone */
+    min?: number;
+    /** Max number of fields that should be mapped to the zone */
+    max?: number;
+    /** Array of allowed fields for the zone */
+    only?: string[];
+}
+export interface ZoneField {
+    field: string;
+    displayName: string;
+    label: string;
+    renderer: ColumnRenderer;
+    column: Column;
+    chooserGroup: string;
+    sortable: boolean;
+    sortingOrder: ColumnSortSpec[];
+}
+export interface ZoneGridModelPersistOptions extends PersistOptions {
+    /** True (default) to include mapping state or provide mapping-specific PersistOptions. */
+    persistMappings?: boolean | PersistOptions;
+    /** True (default) to include grouping state or provide grouping-specific PersistOptions. */
+    persistGrouping?: boolean | PersistOptions;
+    /** True (default) to include sort state or provide sort-specific PersistOptions. */
+    persistSort?: boolean | PersistOptions;
+}

package/build/types/cmp/zoneGrid/ZoneGrid.d.ts

@@ -0,0 +1,24 @@
+import { HoistProps, LayoutProps, TestSupportProps } from '@xh/hoist/core';
+import { GridOptions } from '@xh/hoist/kit/ag-grid';
+import { ZoneGridModel } from './ZoneGridModel';
+import './ZoneGrid.scss';
+export interface ZoneGridProps<M extends ZoneGridModel = ZoneGridModel> extends HoistProps<M>, LayoutProps, TestSupportProps {
+    /**
+     * Options for ag-Grid's API.
+     *
+     * This constitutes an 'escape hatch' for applications that need to get to the underlying
+     * ag-Grid API. It should be used with care. Settings made here might be overwritten and/or
+     * interfere with the implementation of this component and its use of the ag-Grid API.
+     *
+     * Note that changes to these options after the component's initial render will be ignored.
+     */
+    agOptions?: GridOptions;
+}
+/**
+ * A ZoneGrid is a specialized version of the Grid component.
+ *
+ * It displays its data with multi-line full-width rows, each broken into four zones for
+ * top/bottom and left/right - (tl, tr, bl, br). Zone mappings determine which of the
+ * available fields should be extracted from the record and rendered into each zone.
+ */
+export declare const ZoneGrid: import("react").FC<ZoneGridProps<ZoneGridModel>>, zoneGrid: import("@xh/hoist/core").ElementFactory<ZoneGridProps<ZoneGridModel>>;