@xh/hoist 75.0.0-SNAPSHOT.1754329446115 → 75.0.0-SNAPSHOT.1754347635253

package/CHANGELOG.md

@@ -25,9 +25,15 @@
   operation fails. Set to `false` to fail silently (the behavior prior to this change).
 * Added new `Cube.modifyRecordsAsync` for modifying individual field values in a local uncommitted
   state. Additionally enhanced `Store.modifyRecords` to return a `StoreChangeLog` of updates.
+* Cube Views now emit data objects of type `ViewRowData`, rather than an anonymous `PlainObject`.
+  This new object supports several documented properties, including a useful `cubeLeaves` property,
+  which can be activated via the `Query.provideLeaves` property.
+
+
 
 ### 🐞 Bug Fixes
-* Fixed bug where `Store.modifyRecords` was not properly handling changes to `SummaryRecords`.
+* Fixed bugs where `Store.modifyRecords`, `Store.revertRecords` and `Store.revert` were not properly
+  handling changes to `SummaryRecords`.
 
 ### 🐞 Bug Fixes
 
@@ -59,6 +65,8 @@
 * Removed deprecated `FetchService.setDefaultHeaders`
 * Removed deprecated `FetchService.setDefaultTimeout`
 * Removed deprecated `IdentityService.logoutAsync`
+* Change to the row objects returned by `View`: the undocumented `_meta` and `buckets` properties
+  have been removed. Use the documented properties on the new `ViewRowData` class instead.
 
 ### ✨ Styles
 

package/admin/tabs/activity/tracking/ActivityTrackingModel.ts

@@ -16,7 +16,7 @@ import {FormModel} from '@xh/hoist/cmp/form';
 import {ColumnRenderer, ColumnSpec, GridModel, TreeStyle} from '@xh/hoist/cmp/grid';
 import {GroupingChooserModel} from '@xh/hoist/cmp/grouping';
 import {HoistModel, LoadSpec, managed, PlainObject, XH} from '@xh/hoist/core';
-import {Cube, CubeFieldSpec, FieldSpec, StoreRecord} from '@xh/hoist/data';
+import {Cube, CubeFieldSpec, FieldSpec, ViewRowData} from '@xh/hoist/data';
 import {dateRenderer, dateTimeSecRenderer, numberRenderer} from '@xh/hoist/format';
 import {action, computed, makeObservable, observable} from '@xh/hoist/mobx';
 import {LocalDate} from '@xh/hoist/utils/datetime';
@@ -135,7 +135,8 @@ export class ActivityTrackingModel extends HoistModel implements ActivityDetailP
             },
             {
                 track: () => this.gridModel.selectedRecords,
-                run: recs => (this.trackLogs = this.getAllLeafRows(recs)),
+                run: recs =>
+                    (this.trackLogs = recs.flatMap(r => (r.raw as ViewRowData).cubeLeaves)),
                 debounce: 100
             }
         );
@@ -231,29 +232,13 @@ export class ActivityTrackingModel extends HoistModel implements ActivityDetailP
             data = cube.executeQuery({
                 dimensions,
                 includeRoot: true,
-                includeLeaves: true
+                provideLeaves: true
             });
 
-        data.forEach(node => this.separateLeafRows(node));
         gridModel.loadData(data);
         await gridModel.preSelectFirstAsync();
     }
 
-    // Cube emits leaves in "children" collection - rename that collection to "leafRows" so we can
-    // carry the leaves with the record, but deliberately not show them in the tree grid. We only
-    // want the tree grid to show aggregate records.
-    private separateLeafRows(node) {
-        if (isEmpty(node.children)) return;
-
-        const childrenAreLeaves = !node.children[0].children;
-        if (childrenAreLeaves) {
-            node.leafRows = node.children;
-            delete node.children;
-        } else {
-            node.children.forEach(child => this.separateLeafRows(child));
-        }
-    }
-
     private cubeLabelComparator(valA, valB, sortDir, abs, {recordA, recordB, defaultComparator}) {
         const rawA = recordA?.raw,
             rawB = recordB?.raw,
@@ -291,23 +276,6 @@ export class ActivityTrackingModel extends HoistModel implements ActivityDetailP
         };
     }
 
-    // Extract all leaf, track-entry-level rows from an aggregate record (at any level).
-    private getAllLeafRows(aggRecs: StoreRecord[], ret = []): PlainObject[] {
-        if (isEmpty(aggRecs)) return [];
-
-        aggRecs.forEach(aggRec => {
-            if (aggRec.children.length) {
-                this.getAllLeafRows(aggRec.children, ret);
-            } else if (aggRec.raw.leafRows) {
-                aggRec.raw.leafRows.forEach(leaf => {
-                    ret.push({...leaf});
-                });
-            }
-        });
-
-        return ret;
-    }
-
     //------------------------
     // Impl - core data models
     //------------------------

package/build/types/admin/tabs/activity/tracking/ActivityTrackingModel.d.ts

@@ -49,11 +49,9 @@ export declare class ActivityTrackingModel extends HoistModel implements Activit
     getDisplayName(fieldName: string): string;
     private createQueryFormModel;
     private loadGridAsync;
-    private separateLeafRows;
     private cubeLabelComparator;
     private getComparableValForDim;
     private get query();
-    private getAllLeafRows;
     private createAndSetCoreModels;
     private createCube;
     private createFilterChooserModel;

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

@@ -407,4 +407,5 @@ export declare class Store extends HoistBase {
     private createFieldMap;
     private parseExperimental;
     private parseIdSpec;
+    private revertSummaryRecords;
 }

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

@@ -1,4 +1,7 @@
 import { BaseRow } from './row/BaseRow';
+/**
+ * @see BucketSpecFn
+ */
 export declare class BucketSpec {
     name: string;
     bucketFn: (row: BaseRow) => string;

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

@@ -1,5 +1,6 @@
 import { HoistBase, PlainObject, Some } from '@xh/hoist/core';
 import { CubeField, CubeFieldSpec } from './CubeField';
+import { ViewRowData } from './ViewRowData';
 import { QueryConfig } from './Query';
 import { View } from './View';
 import { Store, StoreRecordIdSpec, StoreTransaction } from '../Store';
@@ -36,6 +37,32 @@ export interface CubeConfig {
      */
     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 BucketSpec for configuring 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.
  *
@@ -74,41 +101,37 @@ export declare class Cube extends HoistBase {
      * @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): any;
+    executeQuery(query: QueryConfig): ViewRowData[];
     /**
-     * Create a View on this data.
+     * 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.
      *
-     * Creates a dynamic View of the cube data, based on a query.  Useful for binding to grids a
-     * and efficiently displaying changing results in the Cube.
+     * 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.
      *
-     * Note: Applications should call {@link View.disconnect} or {@link View.destroy} on the View
-     * created by this method when appropriate to avoid unnecessary processing.
+     * 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 loaded/reloaded with data from this view.
-     *      To receive data only, use the 'results' property of the returned View instead.
-     * @param connect - true to update View automatically when data in
-     *      the underlying cube is changed. Default false.
+     * @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.
-     */
+    /** True if the provided view is connected to this Cube for live updates. */
     viewIsConnected(view: View): boolean;
-    /** @param view - view to disconnect from live updates. */
+    /** Cease pushing further updates to this Cube's data into a previously connected View. */
     disconnectView(view: View): void;
     /**
      * Populate this cube with a new dataset.
+     * This method largely delegates to {@link Store.loadData} - see that method for more info.
      *
-     * This method largely delegates to Store.loadData().  See that method for more
-     * information.
-     *
-     * Note that this method will update its views asynchronously, in order to avoid locking
-     * up the browser when attached to multiple expensive views.
+     * 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.
@@ -150,25 +173,3 @@ export declare class Cube extends HoistBase {
     private parseFields;
     destroy(): void;
 }
-/**
- * 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 each dimension to determine if children of said dimension should be
- * bucketed into additional dynamic dimensions.
- *
- * @param rows - the rows being checked for bucketing
- * @returns a BucketSpec for configuring the bucket to place child rows into, or null to perform
- *          no bucketing
- */
-export type BucketSpecFn = (rows: BaseRow[]) => BucketSpec;

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

@@ -1,41 +1,68 @@
-import { BucketSpecFn, Filter, LockFn, OmitFn, StoreRecord } from '@xh/hoist/data';
-import { FilterLike } from '../filter/Types';
-import { CubeField } from './CubeField';
+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 from a cube and how it should be grouped + aggregated.
- *
- * Note that if no dimensions are provided, 'includeRoot' or 'includeLeaves' should be true -
- * otherwise no data will be returned!
+ * Queries determine what data is extracted, grouped, and aggregated from a {@link Cube}.
  */
 export interface QueryConfig {
     /**
-     * Associated Cube. Required, but note that `Cube.executeQuery()` will install a reference to
-     * itself on the query config (automatically)
+     * 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 fields
-     * from the source Cube, otherwise supply a subset to optimize aggregation performance.
+     * 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 to group on. Any fields provided must also be in fields config, above. If none
-     * given the resulting data will not be grouped.
+     * 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'].
+     *
+     * Any fields provided here must also be included in the `fields` array, if specified.
+     *
+     * 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[];
     /**
-     * One or more filters or configs to create one.  If an array, a single 'AND' filter will
-     * be created.
+     * 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;
     /**
-     * IncludeRoot?: True to include a synthetic root node in the return with grand total
-     * aggregate values.
+     * 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 in return.*/
+    /**
+     * 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`.
@@ -43,13 +70,20 @@ export interface QueryConfig {
     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 Cube.lockFn.
+     * 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.
-     * Defaults to Cube.bucketSpecFn.
+     *
+     * 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 BucketSpec} interface for additional information.
+     *
+     * Defaults to {@link Cube.bucketSpecFn}.
      */
     bucketSpecFn?: BucketSpecFn;
     /**
@@ -65,13 +99,14 @@ export declare class Query {
     readonly filter: Filter;
     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, omitRedundantNodes, lockFn, bucketSpecFn, omitFn }: QueryConfig);
+    constructor({ cube, fields, dimensions, filter, includeRoot, includeLeaves, provideLeaves, omitRedundantNodes, lockFn, bucketSpecFn, omitFn }: QueryConfig);
     clone(overrides: Partial<QueryConfig>): Query;
     test(record: StoreRecord): boolean;
     /**
@@ -79,8 +114,7 @@ export declare class Query {
      */
     equals(other: Query): boolean;
     /**
-     * True if the provided other Query is equivalent to this instance,
-     * not considering the filter.
+     * True if the provided other Query is equivalent to this instance, not considering the filter.
      */
     equalsExcludingFilter(other: Query): boolean;
     private parseFields;

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

@@ -1,22 +1,28 @@
 import { HoistBase, PlainObject, Some } from '@xh/hoist/core';
 import { Cube, CubeField, Filter, FilterLike, Query, QueryConfig, Store, 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 the View's
-     * observable `result` property directly to use without a Store.
+     * 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 `result` and any connected store(s) when data in the
-     * underlying Cube is changed. False (default) to have this view run its query once to capture
-     * a snapshot without further updates based on Cube changes.
+     * 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;
@@ -29,27 +35,24 @@ export interface DimensionValue {
  */
 export declare class View extends HoistBase {
     get isView(): boolean;
-    /** Query defining this View. Update via `updateQuery()`. */
+    /** 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 data objects.
+     * Results of this view, an observable object with a `rows` property containing an array of
+     * hierarchical {@link ViewRowData} objects.
      */
-    result: {
-        rows: PlainObject[];
-        leafMap: Map<StoreRecordId, LeafRow>;
-    };
+    result: ViewResult;
     /** Stores to which results of this view should be (re)loaded. */
     stores: Store[];
-    /** Cube info associated with this View when last updated. */
+    /** The source {@link Cube.info} as of the last time this View was updated. */
     info: PlainObject;
-    /** timestamp (ms) of the last time this view's data was changed. */
+    /** Timestamp (ms) of the last time this view's data was changed. */
     lastUpdated: number;
-    private _rows;
-    private _rowCache;
+    private _rowDatas;
     private _leafMap;
     private _recordMap;
     _aggContext: AggregationContext;
+    _rowCache: Map<string, BaseRow>;
     /** @internal - applications should use {@link Cube.createView} */
     constructor(config: ViewConfig);
     get cube(): Cube;
@@ -64,13 +67,10 @@ export declare class View extends HoistBase {
      * 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. May include any arguments to the query
-     *      constructor except `cube`, which cannot be changed on a view once set
-     *      via the initial query.
+     *      constructor except `cube`, which cannot be changed once set via the initial query.
      */
     updateQuery(overrides: Partial<QueryConfig>): void;
-    /**
-     * Gathers all unique values for each dimension field in the query
-     */
+    /** Gather all unique values for each dimension field in the query. */
     getDimensionValues(): DimensionValue[];
     /** Get a specific Field by name.*/
     getField(name: string): CubeField;

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

@@ -0,0 +1,40 @@
+import { PlainObject, 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 implements PlainObject {
+    constructor(id: string);
+    /** Unique id. */
+    id: string;
+    /**
+     * 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>;
+    /** @internal */
+    _cubeLeafChildren: ViewRowData[];
+}

package/build/types/data/cube/row/AggregateRow.d.ts

@@ -3,10 +3,13 @@ import { CubeField } from '../CubeField';
 import { View } from '../View';
 import { BaseRow } from './BaseRow';
 /**
- *  Object used by views to gather Aggregate rows.
+ *  Row within a dataset produced by a Cube / View representing aggregated data on a dimension.
+ *
+ * This is an internal data structure - {@link ViewRowData} is the public row-level data API.
  */
 export declare class AggregateRow extends BaseRow {
     get isAggregate(): boolean;
+    /** The dimension for which this row is aggregating data. Null for a top-level summary row. */
     readonly dim: CubeField;
     readonly dimName: string;
     constructor(view: View, id: string, children: BaseRow[], dim: CubeField, val: any, strVal: string, appliedDimensions: PlainObject);

package/build/types/data/cube/row/BaseRow.d.ts

@@ -1,14 +1,17 @@
 import { PlainObject, Some } from '@xh/hoist/core';
 import { BucketSpec } from '@xh/hoist/data/cube/BucketSpec';
+import { ViewRowData } from '@xh/hoist/data/cube/ViewRowData';
 import { View } from '../View';
 import { RowUpdate } from './RowUpdate';
 /**
- * Base class for a view row.
+ * Base class for a row within a dataset produced by a Cube / View.
+ *
+ * This is an internal data structure - {@link ViewRowData} is the public row-level data API.
  */
 export declare abstract class BaseRow {
     readonly view: View;
     readonly id: string;
-    readonly data: PlainObject;
+    readonly data: ViewRowData;
     parent: BaseRow;
     children: BaseRow[];
     locked: boolean;
@@ -18,8 +21,8 @@ export declare abstract class BaseRow {
     get isBucket(): boolean;
     constructor(view: View, id: string);
     noteBucketed(bucketSpec: BucketSpec, bucketVal: any): void;
-    getVisibleDatas(): Some<PlainObject>;
-    private getVisibleChildrenDatas;
+    getVisibleDatas(): Some<ViewRowData>;
+    private getChildrenDatas;
     private isRedundantChild;
     protected initAggregate(children: BaseRow[], dimOrBucketName: string, val: any, appliedDimensions: PlainObject): void;
     applyDataUpdate(childUpdates: RowUpdate[], updatedRowDatas: Set<PlainObject>): void;

package/build/types/data/cube/row/BucketRow.d.ts

@@ -3,7 +3,11 @@ import { BaseRow } from './BaseRow';
 import { BucketSpec } from '../BucketSpec';
 import { View } from '../View';
 /**
- *  Object used by views to gather bucket rows.
+ *  Row within a dataset produced by a Cube / View representing aggregated data on a dimension that
+ *  has been further grouped into a dynamic child "bucket" - a subset of the dimension-level
+ *  {@link AggregateRow} produced as per a specified {@link Query.bucketSpecFn}.
+ *
+ * This is an internal data structure - {@link ViewRowData} is the public row-level data API.
  */
 export declare class BucketRow extends BaseRow {
     get isBucket(): boolean;

package/build/types/data/cube/row/LeafRow.d.ts

@@ -3,15 +3,16 @@ import { StoreRecord, StoreRecordId } from '@xh/hoist/data';
 import { View } from '../View';
 import { BaseRow } from './BaseRow';
 /**
- * Represents a leaf row returned by a {@link View} or call to {@link Cube.executeQuery}.
- *
- * These rows are 1-1 with the source records loaded into the Cube's internal store - i.e. they are
- * not computed aggregates - although the data they contain is a shallow copy of the original and
+ * Row within a dataset produced by a Cube or View representing leaf-level data. These rows have a
+ * 1-1 relationship with the source records loaded into the Cube's internal store - i.e. they are
+ * not computed aggregates, although the data they contain is a shallow copy of the original and
  * limited to the fields requested by the View / Query that produced them.
+ *
+ * This is an internal data structure - {@link ViewRowData} is the public row-level data API.
  */
 export declare class LeafRow extends BaseRow {
     /**
-     * Id of the StoreRecord within the Cube that was used to construct this leaf row.
+     * ID of the `StoreRecord` within the Cube that was used to construct this leaf row.
      * Useful if you need to update this leaf's data via {@link Cube.updateDataAsync}.
      */
     readonly cubeRecordId: StoreRecordId;

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

@@ -26,6 +26,7 @@ export * from './cube/Cube';
 export * from './cube/CubeField';
 export * from './cube/Query';
 export * from './cube/View';
+export * from './cube/ViewRowData';
 export * from './validation/constraints';
 export * from './validation/Rule';
 export * from './validation/ValidationState';