@xh/hoist 82.0.1 → 82.0.3

package/build/types/data/UrlStore.d.ts

@@ -0,0 +1,27 @@
+import { Loadable, LoadSpec, LoadSupport, PlainObject, TaskObserver } from '@xh/hoist/core';
+import { Store, StoreConfig } from './Store';
+export interface UrlStoreConfig extends StoreConfig {
+    /** URL from which to load data. */
+    url: string;
+    /** Property name (key) of the object returned by URL from which to extract record data. */
+    dataRoot?: string;
+}
+/**
+ * A store with built-in support for loading data from a URL.
+ */
+export declare class UrlStore extends Store implements Loadable {
+    url: string;
+    dataRoot: string;
+    loadSupport: LoadSupport;
+    constructor({ url, dataRoot, ...storeConfig }: UrlStoreConfig);
+    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>;
+    loadAsync(loadSpec?: LoadSpec | Partial<LoadSpec>): Promise<void>;
+    /** @internal - call loadAsync() instead. */
+    doLoadAsync(loadSpec: LoadSpec): Promise<void>;
+}

package/build/types/data/cube/BucketSpec.d.ts

@@ -0,0 +1,31 @@
+import { BaseRow } from './row/BaseRow';
+import { SetOptional } from '@xh/hoist/core';
+/**
+ * Spec to define a bucketing level within the hierarchy of data returned by a Query, as identified
+ * by a set of rows passed to a {@link BucketSpecFn} configured on that Query (or defaulted from
+ * the Cube). If this object is returned for a candidate set of rows, each row is evaluated by the
+ * spec's `bucketFn` to determine if it should yield a value for the bucket, causing the row to be
+ * nested underneath a new {@link BucketRow} created to hold all rows with that value.
+ */
+export declare class BucketSpec {
+    /** Name for the bucketing level configured by this spec - equivalent to a dimension name. */
+    name: string;
+    /**
+     * Function returning the bucketed value (if any) into which the given row should be placed -
+     * equivalent to a dimension value. Return null/undefined to exclude the row from bucketing.
+     */
+    bucketFn: (row: BaseRow) => string;
+    /**
+     * Function returning bucket row label from the bucket value string returned by bucketFn.
+     * Defaults to using the value directly.
+     */
+    labelFn: (bucket: string) => string;
+    /**
+     * Fields on which the `bucketFn` depends, to ensure rows are re-bucketed if dependent field
+     * values change. If not provided or does not cover all fields potentially accessed by
+     * `bucketFn`, an incremental "data only" update that should have changed a row's bucket can
+     * fail to do so.
+     */
+    dependentFields: string[];
+    constructor(config: SetOptional<BucketSpec, 'labelFn' | 'dependentFields'>);
+}

package/build/types/data/cube/Cube.d.ts

@@ -0,0 +1,180 @@
+import { HoistBase, PlainObject, Some } from '@xh/hoist/core';
+import { Store, StoreRecordIdSpec, StoreTransaction } from '../Store';
+import { StoreRecord } from '../StoreRecord';
+import { BucketSpec } from './BucketSpec';
+import { CubeField, CubeFieldSpec } from './CubeField';
+import { QueryConfig } from './Query';
+import { AggregateRow } from './row/AggregateRow';
+import { BaseRow } from './row/BaseRow';
+import { BucketRow } from './row/BucketRow';
+import { View } from './View';
+import { ViewRowData } from './ViewRowData';
+export interface CubeConfig {
+    fields: CubeField[] | CubeFieldSpec[];
+    /** Default configs applied to all `CubeField`s constructed internally by this Cube. */
+    fieldDefaults?: Partial<CubeFieldSpec>;
+    /** Array of initial raw data. */
+    data?: PlainObject[];
+    /** See {@link StoreConfig.idSpec} */
+    idSpec?: StoreRecordIdSpec;
+    /** See {@link StoreConfig.processRawData} */
+    processRawData?: (data: PlainObject) => PlainObject;
+    /** Convenience bucket for app-specific metadata associated with the loaded dataset. */
+    info?: PlainObject;
+    /**
+     * Optional function to be called for each aggregate node to determine if it should be "locked",
+     * preventing drill-down into its children.
+     */
+    lockFn?: LockFn;
+    /**
+     * Optional function to be called for each dimension during row generation to determine if the
+     * children of that dimension should be bucketed into additional dynamic dimensions.
+     */
+    bucketSpecFn?: BucketSpecFn;
+    /**
+     * Optional function to be called on all single child rows during view processing.
+     * Return true to omit the row.
+     */
+    omitFn?: OmitFn;
+}
+/**
+ * Function to be called for each node to aggregate to determine if it should be "locked",
+ * preventing drilldown into its children. If true returned for a node, no drilldown will be
+ * allowed, and the row will be marked with a boolean "locked" property.
+ */
+export type LockFn = (row: AggregateRow | BucketRow) => boolean;
+/**
+ * Function to be called for each node during row generation to determine if it should be
+ * skipped in tree output.  Useful for removing aggregates that are degenerate due to context.
+ * Note that skipping in this way has no effect on aggregations -- all children of this node are
+ * simply promoted to their parent node.
+ */
+export type OmitFn = (row: AggregateRow | BucketRow) => boolean;
+/**
+ * Function to be called for rows making up an aggregated dimension to determine if the children of
+ * that dimension should be dynamically bucketed into additional sub-groupings.
+ *
+ * An example use case would be a grouped collection of portfolio positions, where any closed
+ * positions are identified as such by this function and bucketed into a "Closed" sub-grouping,
+ * without having to add something like an "openClosed" dimension that would apply to all
+ * aggregations and create an unwanted "Open" grouping.
+ *
+ * @param rows - the rows being checked for bucketing
+ * @returns {@link BucketSpec} for dynamic sub-aggregations, or null to perform no bucketing.
+ */
+export type BucketSpecFn = (rows: BaseRow[]) => BucketSpec;
+/**
+ * A data store that supports grouping, aggregating, and filtering data on multiple dimensions.
+ *
+ * This object is a wrapper around a "flat" Store containing leaf-level facts. It supports creating
+ * Views on that data via structured Queries that can filter, group, and aggregate the flat source
+ * data and produce a hierarchical result ready for use in (e.g.) tree grids and maps. Views can
+ * be transiently created to run a Query once, on demand, or can be retained to provide efficient,
+ * auto-updating results in response to updates to the underlying data.
+ */
+export declare class Cube extends HoistBase {
+    static RECORD_ID_DELIMITER: string;
+    store: Store;
+    lockFn: LockFn;
+    bucketSpecFn: BucketSpecFn;
+    omitFn: OmitFn;
+    info: any;
+    _connectedViews: Set<View>;
+    constructor({ fields, fieldDefaults, data, idSpec, processRawData, info, lockFn, bucketSpecFn, omitFn }: CubeConfig);
+    /** Fields configured for this Cube. */
+    get fields(): CubeField[];
+    /** Dimension Fields configured for this Cube. */
+    get dimensions(): CubeField[];
+    /** Records loaded in to this Cube. */
+    get records(): StoreRecord[];
+    /** True if this Cube contains no data / records. */
+    get empty(): boolean;
+    /** Timestamp (ms) of when the Cube data was last updated */
+    get lastUpdated(): number;
+    /** Count of currently connected, auto-updating Views. */
+    get connectedViewCount(): number;
+    getField(name: string): CubeField;
+    /**
+     * Query the cube.
+     *
+     * This method will return a snapshot of javascript objects representing the filtered
+     * and aggregated data in the query.  In addition to the fields specified in Query, nodes will
+     * each contain a 'cubeLabel' and a 'cubeDimension' property.
+     *
+     * @param query - Config for query defining the shape of the view.
+     * @returns data containing the results of the query as a hierarchical set of rows.
+     */
+    executeQuery(query: QueryConfig): ViewRowData[];
+    /**
+     * Create a dynamic {@link View} of the cube data based on a query. Unlike the static snapshot
+     * returned by {@link Cube.executeQuery}, a View created with this method can be configured
+     * with `connect:true` to automatically update as the underlying data in the Cube changes.
+     *
+     * Provide one or more `stores` to automatically populate them with the aggregated data returned
+     * by the query, or read the returned {@link View.result} directly.
+     *
+     * When the returned View is no longer needed, call {@link View.destroy} (or save a reference
+     * via an `@managed` model property) to avoid unnecessary processing.
+     *
+     * @param query - query to be used to construct this view.
+     * @param stores - Stores to be automatically loaded/reloaded with View results.
+     * @param connect - true to update View automatically when data in the underlying Cube changes.
+     */
+    createView({ query, stores, connect }: {
+        query: QueryConfig;
+        stores?: Store[] | Store;
+        connect?: boolean;
+    }): View;
+    /** True if the provided view is connected to this Cube for live updates. */
+    viewIsConnected(view: View): boolean;
+    /** Cease pushing further updates to this Cube's data into a previously connected View. */
+    disconnectView(view: View): void;
+    /** Connect a View to this Cube for live updates. */
+    connectView(view: View): void;
+    /**
+     * Populate this cube with a new dataset.
+     * This method largely delegates to {@link Store.loadData} - see that method for more info.
+     *
+     * Note that this method will update its views asynchronously in order to avoid locking up the
+     * browser when attached to multiple expensive views.
+     *
+     * @param rawData - flat array of lowest/leaf level data rows.
+     * @param info - optional metadata to associate with this cube/dataset.
+     */
+    loadDataAsync(rawData: PlainObject[], info?: PlainObject): Promise<void>;
+    /**
+     * Update this cube with incremental data set changes and/or info.
+     * This method largely delegates to {@link Store.updateData} - see that method for more info.
+     *
+     * Note that this method will update its views asynchronously in order to avoid locking
+     * up the browser when attached to multiple expensive views.
+     *
+     * @param rawData - data changes to process. If provided as an array, rawData will be processed
+     *      into adds and updates, with updates determined by matching existing records by ID.
+     * @param infoUpdates - new key-value pairs to be applied to existing info on this cube.
+     */
+    updateDataAsync(rawData: PlainObject[] | StoreTransaction, infoUpdates?: PlainObject): Promise<void>;
+    /**
+     * Similar to `updateDataAsync`, but intended for modifying individual field values in a local
+     * uncommitted state - i.e. when updating via an inline grid editor or similar control. Like
+     * `updateDataAsync`, this method will update its views asynchronously.
+     *
+     * This method largely delegates to {@link Store.modifyRecords} - see that method for more info.
+     *
+     * @param modifications - field-level modifications to apply to existing
+     *      Records in this Cube. Each object in the list must have an `id` property identifying
+     *      the StoreRecord to modify, plus any other properties with updated field values to apply,
+     *      e.g. `{id: 4, quantity: 100}, {id: 5, quantity: 99, customer: 'bob'}`.
+     */
+    modifyRecordsAsync(modifications: Some<PlainObject>): Promise<void>;
+    /** Clear any/all data and info from this Cube. */
+    clearAsync(): Promise<void>;
+    /**
+     * Populate the metadata associated with this cube.
+     * @param infoUpdates - new key-value pairs to be applied to existing info on this cube.
+     */
+    updateInfo(infoUpdates?: PlainObject): void;
+    private setInfo;
+    private parseFields;
+    destroy(): void;
+}

package/build/types/data/cube/CubeField.d.ts

@@ -0,0 +1,49 @@
+import { PlainObject } from '@xh/hoist/core';
+import { AggregationContext, Aggregator, AverageAggregator, AverageStrictAggregator, ChildCountAggregator, Field, FieldSpec, LeafCountAggregator, MaxAggregator, MinAggregator, NullAggregator, SingleAggregator, SumAggregator, SumStrictAggregator, UniqueAggregator } from '@xh/hoist/data';
+export interface CubeFieldSpec extends FieldSpec {
+    /** Instance of a Hoist Cube {@link Aggregator} or string token alias for one. */
+    aggregator?: Aggregator | AggregatorToken;
+    /** Function to determine if aggregation should be performed at a given level of a query result. */
+    canAggregateFn?: CanAggregateFn;
+    /** True if any further groupings below this dimension would be derivative (have only one member). */
+    isLeafDimension?: boolean;
+    /**
+     * Name of field that is a 'parent' dimension of this dimension. This marks this dimension as a
+     * sub-dimension of the parent dimension (e.g. 'asset group' and 'asset'). This allows the view
+     * to skip creating derivative nodes when a parent node has a single identical child node.
+     */
+    parentDimension?: string;
+}
+/** Convenient (and serializable) alias for one of Hoist's Cube {@link Aggregator} classes. */
+export type AggregatorToken = 'AVG' | 'AVG_STRICT' | 'CHILD_COUNT' | 'LEAF_COUNT' | 'MAX' | 'MIN' | 'NULL' | 'SINGLE' | 'SUM' | 'SUM_STRICT' | 'UNIQUE';
+/**
+ * @param dimension - dimension of aggregation
+ * @param value - value of record on dimension
+ * @param appliedDims - *all* applied dimension values for this record
+ * @param context - current aggregation context
+ */
+export type CanAggregateFn = (dimension: string, value: any, appliedDims: PlainObject, context: AggregationContext) => boolean;
+/**
+ * Metadata used to define a measure or dimension in Cube. For properties present on raw data source
+ * objects to be included in a Cube, the Cube must be configured with a matching Field that tells
+ * it to extract the data from the source objects and how to aggregate or filter on that data.
+ */
+export declare class CubeField extends Field {
+    aggregator: Aggregator;
+    canAggregateFn: CanAggregateFn;
+    isLeafDimension: boolean;
+    parentDimension: string;
+    static averageAggregator: AverageAggregator;
+    static averageStrictAggregator: AverageStrictAggregator;
+    static childCountAggregator: ChildCountAggregator;
+    static leafCountAggregator: LeafCountAggregator;
+    static maxAggregator: MaxAggregator;
+    static minAggregator: MinAggregator;
+    static nullAggregator: NullAggregator;
+    static singleAggregator: SingleAggregator;
+    static sumAggregator: SumAggregator;
+    static sumStrictAggregator: SumStrictAggregator;
+    static uniqueAggregator: UniqueAggregator;
+    constructor({ aggregator, canAggregateFn, isLeafDimension, parentDimension, ...fieldArgs }: CubeFieldSpec);
+    private parseAggregator;
+}

package/build/types/data/cube/Query.d.ts

@@ -0,0 +1,121 @@
+import { BucketSpecFn, Filter, FilterLike, LockFn, OmitFn, StoreRecord } from '@xh/hoist/data';
+import { Cube } from './Cube';
+import { CubeField } from './CubeField';
+/**
+ * Queries determine what data is extracted, grouped, and aggregated from a {@link Cube}.
+ */
+export interface QueryConfig {
+    /**
+     * The Cube to query. Required, but note that the preferred {@link Cube.executeQuery} API will
+     * install a reference to itself on the query config (automatically).
+     */
+    cube?: Cube;
+    /**
+     * Fields or field names. If unspecified will include all available {@link Cube.fields}.
+     * Specify a subset to optimize aggregation performance.
+     */
+    fields?: string[] | CubeField[];
+    /**
+     * Fields or field names on which data should be grouped and aggregated. These are the ordered
+     * grouping levels in the resulting hierarchy - e.g. ['Country', 'State', 'City'].
+     *
+     * If not provided or empty, the resulting data will not be grouped. Specify 'includeRoot' or
+     * 'includeLeaves' in that case, otherwise no data will be returned.
+     */
+    dimensions?: string[] | CubeField[];
+    /**
+     * Filters to apply to leaf data, or configs to create. Note that leaf data will be filtered
+     * and then aggregated - i.e. the filters provided here will filter in/out the lowest level
+     * facts and _won't_ operate directly on any aggregates.
+     *
+     * Arrays will be combined into a single 'AND' CompoundFilter.
+     */
+    filter?: FilterLike;
+    /**
+     * True to include a synthetic root node in the return with grand totals (aggregations across
+     * all data returned by the query). Pairs well with {@link StoreConfig.loadRootAsSummary} and
+     * {@link GridConfig.showSummary} to display a docked grand total row for grids rendering
+     * Cube results.
+     */
+    includeRoot?: boolean;
+    /**
+     * True to include leaf nodes (the "flat" facts originally loaded into the Cube) as the
+     * {@link ViewRowData.children} of the lowest level of aggregated `dimensions`.
+     *
+     * False (the default) to only return aggregate rows based on requested `dimensions`.
+     *
+     * Useful when you wish to e.g. load Cube results into a tree grid and allow users to expand
+     * aggregated groups all the way out to see the source data. See also `provideLeaves`, which
+     * will provide access to these nodes without exposing as `children`.
+     */
+    includeLeaves?: boolean;
+    /**
+     * True to provide access to leaf nodes via the {@link ViewRowData.cubeLeaves} getter on the
+     * lowest level of aggregated `dimensions`. This will allow programmatic access to the leaves
+     * used to produce a given aggregation, without exposing them as `children` in a way that would
+     * cause them to be rendered in a tree grid.
+     *
+     * Useful when e.g. a full leaf-level drill-down is not desired, but the app still needs
+     * access to those leaves to display in a separate view or for further processing.
+     *
+     * See also the more common `includeLeaves`.
+     */
+    provideLeaves?: boolean;
+    /**
+     * True (default) to recursively omit single-child parents in the hierarchy.
+     * Apps can implement further omit logic using `omitFn`.
+     */
+    omitRedundantNodes?: boolean;
+    /**
+     * Optional function to be called for each aggregate node to determine if it should be "locked",
+     * preventing drill-down into its children.
+     *
+     * Defaults to {@link Cube.lockFn}.
+     */
+    lockFn?: LockFn;
+    /**
+     * Optional function to be called for each dimension during row generation to determine if the
+     * children of that dimension should be bucketed into additional dynamic dimensions.
+     *
+     * This can be used to break selected aggregations into sub-groups dynamically, without having
+     * to define another dimension in the Cube and have it apply to all aggregations. See the
+     * {@link BucketSpecFn} type and {@link BucketSpec} interface for additional information.
+     *
+     * Defaults to {@link Cube.bucketSpecFn}.
+     */
+    bucketSpecFn?: BucketSpecFn;
+    /**
+     * Optional function to be called on all single child rows during view processing.
+     * Return true to omit the row. Defaults to Cube.omitFn.
+     */
+    omitFn?: OmitFn;
+}
+/** {@inheritDoc QueryConfig} */
+export declare class Query {
+    readonly fields: CubeField[];
+    readonly dimensions: CubeField[];
+    readonly filter: Filter;
+    readonly hasFilter: boolean;
+    readonly includeRoot: boolean;
+    readonly includeLeaves: boolean;
+    readonly provideLeaves: boolean;
+    readonly omitRedundantNodes: boolean;
+    readonly cube: Cube;
+    readonly lockFn: LockFn;
+    readonly bucketSpecFn: BucketSpecFn;
+    readonly omitFn: OmitFn;
+    private readonly _testFn;
+    constructor({ cube, fields, dimensions, filter, includeRoot, includeLeaves, provideLeaves, omitRedundantNodes, lockFn, bucketSpecFn, omitFn }: QueryConfig);
+    clone(overrides: Partial<QueryConfig>): Query;
+    test(record: StoreRecord): boolean;
+    /**
+     * True if the provided other Query is equivalent to this instance.
+     */
+    equals(other: Query): boolean;
+    /**
+     * True if the provided other Query is equivalent to this instance, not considering the filter.
+     */
+    equalsExcludingFilter(other: Query): boolean;
+    private parseFields;
+    private parseDimensions;
+}

package/build/types/data/cube/View.d.ts

@@ -0,0 +1,106 @@
+import type { GridFilterBindTarget } from '@xh/hoist/cmp/grid';
+import { HoistBase, PlainObject, Some } from '@xh/hoist/core';
+import { Cube, CubeField, Filter, FilterBindTarget, FilterLike, FilterValueSource, Query, QueryConfig, Store, StoreChangeLog, StoreRecordId } from '@xh/hoist/data';
+import { ViewRowData } from '@xh/hoist/data/cube/ViewRowData';
+import { AggregationContext } from './aggregate/AggregationContext';
+import { BaseRow } from './row/BaseRow';
+import { LeafRow } from './row/LeafRow';
+export interface ViewConfig {
+    /** Query to be used to construct this view. */
+    query: Query;
+    /**
+     * Store(s) to be automatically (re)loaded with data from this view.
+     * Optional - read {@link View.result} directly to use without a Store.
+     */
+    stores?: Store[] | Store;
+    /**
+     * True to reactively update the View's {@link View.result} and any connected store(s) when data
+     * in the underlying Cube changes. False (default) to have this view run its query once to
+     * capture a snapshot without further (automatic) updates.
+     */
+    connect?: boolean;
+}
+export interface ViewResult {
+    rows: ViewRowData[];
+    leafMap: Map<StoreRecordId, LeafRow>;
+}
+export interface DimensionValue {
+    /** Dimension field. */
+    field: CubeField;
+    /** Unique non-null values for the dimension */
+    values: Set<any>;
+}
+/**
+ * Primary interface for consuming grouped and aggregated data from the cube.
+ * Applications should create via the {@link Cube.createView} factory.
+ */
+export declare class View extends HoistBase implements FilterBindTarget, FilterValueSource, GridFilterBindTarget {
+    static isView(obj: unknown): obj is View;
+    readonly isFilterValueSource = true;
+    /** Query defining this View. Update via {@link updateQuery}. */
+    query: Query;
+    /**
+     * Results of this view, an observable object with a `rows` property containing an array of
+     * hierarchical {@link ViewRowData} objects.
+     */
+    result: ViewResult;
+    /** Stores to which results of this view should be (re)loaded. */
+    stores: Store[];
+    /** The source {@link Cube.info} as of the last time the view was updated. */
+    info: PlainObject;
+    /** The source {@link Cube.lastUpdated} as of the last time the view was updated. */
+    cubeUpdated: number;
+    /** Timestamp (ms) when the view was last updated. */
+    lastUpdated: number;
+    private _rowDatas;
+    private _leafMap;
+    private _recordMap;
+    private _bucketDependentFields;
+    _aggContext: AggregationContext;
+    _rowCache: Map<string, BaseRow>;
+    /** @internal - applications should use {@link Cube.createView} */
+    constructor(config: ViewConfig);
+    get cube(): Cube;
+    get fields(): CubeField[];
+    get fieldNames(): string[];
+    get filter(): Filter;
+    get isConnected(): boolean;
+    get isFiltered(): boolean;
+    /** Stop receiving live updates into this view when the linked Cube data changes. */
+    disconnect(): void;
+    /** Connect to the associated Cube to begin receiving live updates. */
+    connect(): void;
+    /**
+     * Change the query in some way, re-computing the data in this View to reflect the new query.
+     *
+     * @param overrides - changes to be applied to the query. If changing the `cube` and currently
+     *      connected, then we will disconnect from the old cube and connect to the new one.
+     */
+    updateQuery(overrides: Partial<QueryConfig>): void;
+    /** Gather all unique values for each dimension field in the query. */
+    getDimensionValues(): DimensionValue[];
+    /** Get a specific Field by name.*/
+    getField(name: string): CubeField;
+    /** Set stores to be loaded/reloaded with data from this view. */
+    setStores(stores: Some<Store>): void;
+    /** Update the filter on the current Query.*/
+    setFilter(filter: FilterLike): void;
+    noteCubeLoaded(): void;
+    noteCubeUpdated(changeLog: StoreChangeLog): void;
+    getValuesForFieldFilter(fieldName: string, filter?: Filter): any[];
+    private fullUpdate;
+    private dataOnlyUpdate;
+    private loadStores;
+    private updateResults;
+    private generateRows;
+    private groupAndInsertRecords;
+    private bucketRows;
+    private getSimpleUpdates;
+    private hasDimOrBucketUpdates;
+    private cachedRow;
+    private filterRecords;
+    private createAggregationContext;
+    private get aggregatorsAreSimple();
+    private parseStores;
+    destroy(): void;
+}

package/build/types/data/cube/ViewRowData.d.ts

@@ -0,0 +1,46 @@
+import { Some } from '@xh/hoist/core';
+/**
+ * Grouped node data, as returned by {@link Cube.executeQuery} or exposed via {@link View.result}.
+ * Designed for direct consumption by hierarchical stores and their associated tree grids.
+ */
+export declare class ViewRowData {
+    constructor(id: string);
+    /** Unique id. */
+    id: string;
+    /** Denotes a type for the row */
+    cubeRowType: 'leaf' | 'aggregate' | 'bucket';
+    /**
+     * Label of the row. The dimension value or, for leaf rows. the underlying cubeId.
+     * Suitable for display, although apps will typically wish to customize leaf row rendering.
+     */
+    cubeLabel: string;
+    /** Dimension on which this row was computed, or null for leaf rows. */
+    cubeDimension: string;
+    /**
+     * Buckets this row appears in
+     */
+    cubeBuckets: Record<string, any>;
+    /**
+     * Visible children of this row.
+     *
+     * Note that this may not be the same as the simple aggregation children of this row.  In
+     * particular, this property is subject to the semantics of row locking, redundant row omission,
+     * and bucketing as defined by the Query.
+     */
+    children: ViewRowData[];
+    /** True for leaf rows loaded into the cube (i.e. not a grouped aggregation). */
+    get isCubeLeaf(): boolean;
+    /**
+     * All visible (i.e. non-locked) cube leaves associated with this row.
+     *
+     * For this to be populated, either {@link Query.includeLeaves} or {@link Query.provideLeaves}
+     * must have been set on the underlying Query.
+     */
+    get cubeLeaves(): Some<ViewRowData>;
+    /**
+     * Support all other string keys for application fields in source data.
+     */
+    [key: string]: any;
+    /** @internal */
+    _cubeLeafChildren: ViewRowData[];
+}

package/build/types/data/cube/aggregate/AggregationContext.d.ts

@@ -0,0 +1,21 @@
+import { StoreRecord } from '../../StoreRecord';
+import { View } from '../View';
+/**
+ * Context provided to aggregators.
+ *
+ * This context will remain over the lifetime of an aggregation update of a view, and can therefore
+ * be used by aggregators to accumulate or cache values needed for the current set of records.
+ * It will be replaced if the current set of records is being changed in any way.
+ */
+export declare class AggregationContext {
+    /** View being aggregated. */
+    view: View;
+    /** All records currently meeting the filter for this view.*/
+    filteredRecords: StoreRecord[];
+    /**
+     * Custom aggregators may use to store pre-computed values.  Custom aggregators should
+     * take care to appropriately namespace any data stored within this object.
+     */
+    appData: any;
+    constructor(view: View, filteredRecords: StoreRecord[]);
+}

package/build/types/data/cube/aggregate/Aggregator.d.ts

@@ -0,0 +1,40 @@
+import { AggregationContext } from './AggregationContext';
+import { BaseRow } from '../row/BaseRow';
+import { LeafRow } from '../row/LeafRow';
+import { RowUpdate } from '../row/RowUpdate';
+export declare abstract class Aggregator {
+    /**
+     * Does this aggregator depend only on leaf nodes contained by the node being aggregated?
+     *
+     * By default this property returns true, indicating to the cube that if all children of a
+     * given node are the same, the node does not need to be re-aggregated.  Aggregators that
+     * depend on global values (e.g. % of total) should return false for this value.
+     */
+    get dependsOnChildrenOnly(): boolean;
+    /**
+     * Aggregate values
+     * @param rows - current rows in aggregation.  Will never be empty.
+     * @param fieldName - name of field to perform the aggregation on.
+     * @param context - current aggregation context
+     */
+    abstract aggregate(rows: BaseRow[], fieldName: string, context: AggregationContext): any;
+    /**
+     * Adjust an aggregated value, by replacing one of its constituent components.
+     *
+     * @param rows - current rows in aggregation.  Will never be empty.
+     * @param currVal - current value of aggregation
+     * @param update - update that occurred to child of this aggregation.
+     *      Sub-classes may use this method to provide efficient implementations for dynamic changes
+     *      to an aggregation.  The default implementation will simply re-aggregate.
+     * @param context - current aggregation context
+     * @returns new aggregate value
+     */
+    replace(rows: BaseRow[], currVal: any, update: RowUpdate, context: AggregationContext): any;
+    /**
+     * Call function on all *leaf* children of a set of children.
+     *
+     * @param rows - array of child rows
+     * @param fn - the function to call on each leaf.
+     */
+    protected forEachLeaf(rows: BaseRow[], fn: (leaf: LeafRow) => boolean | void): boolean;
+}

package/build/types/data/cube/aggregate/AverageAggregator.d.ts

@@ -0,0 +1,4 @@
+import { Aggregator } from './Aggregator';
+export declare class AverageAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): number;
+}

package/build/types/data/cube/aggregate/AverageStrictAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class AverageStrictAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): number;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/ChildCountAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class ChildCountAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/LeafCountAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class LeafCountAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): number;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/MaxAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class MaxAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/MinAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class MinAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}