@xh/hoist 70.0.0-SNAPSHOT.1731083521069 → 70.0.0-SNAPSHOT.1731623470295

package/build/types/svc/JsonBlobService.d.ts

@@ -1,35 +1,56 @@
-import { HoistService } from '@xh/hoist/core';
+import { HoistService, LoadSpec, PlainObject } from '@xh/hoist/core';
+export interface JsonBlob {
+    /** Either null for private blobs or special token "*" for globally shared blobs. */
+    acl: string;
+    /** True if this blob has been archived (soft-deleted). */
+    archived: boolean;
+    /** Timestamp indicating when this blob was archived, or special value `0` if not archived. */
+    archivedDate: number;
+    dateCreated: number;
+    description: string;
+    /** @internal database ID for this blob. Favor token instead. */
+    id: number;
+    lastUpdated: number;
+    lastUpdatedBy: string;
+    /** Optional application-specific metadata. */
+    meta: PlainObject | unknown[];
+    name: string;
+    /** Username of the blob's creator / owner. */
+    owner: string;
+    /** Primary unique identifier for getting, updating, and archiving blobs. */
+    token: string;
+    /**
+     * Application defined type for this blob. Used as a discriminator when querying blobs related
+     * to a particular use-case within an application.
+     */
+    type: string;
+    /**
+     * Current JSON value of this blob - its contents or data. Will be undefined for blob stubs
+     * returned by `listAsync` if `includeValue` was false.
+     */
+    value?: any;
+}
 /**
  * Service to read and set chunks of user-specific JSON persisted via Hoist Core's JSONBlob class.
+ *
+ * This service is intended as a general, lightweight utility for persisting small bundles of
+ * unstructured data that might not warrant a full-blown domain object, but which still need to be
+ * persisted back to the database.
  */
 export declare class JsonBlobService extends HoistService {
     static instance: JsonBlobService;
-    getAsync(token: any): Promise<any>;
-    /**
-     * Return the list of blobs visible to the current user.
-     *
-     * @param type - reference key for which type of data to list.
-     * @param includeValue - true to include the full value string for each blob.
-     */
-    listAsync({ type, includeValue }: {
+    /** Retrieve a single JSONBlob by its unique token. */
+    getAsync(token: string): Promise<JsonBlob>;
+    /** Retrieve all blobs of a particular type that are visible to the current user. */
+    listAsync({ type, includeValue, loadSpec }: {
         type: string;
         includeValue?: boolean;
+        loadSpec?: LoadSpec;
     }): Promise<any>;
     /** Persist a new JSONBlob back to the server. */
-    createAsync({ type, name, value, meta, description }: {
-        type: string;
-        name: string;
-        description?: string;
-        value: any;
-        meta?: any;
-    }): Promise<any>;
-    /** Modify an existing JSONBlob, as identified by its unique token. */
-    updateAsync(token: string, { name, value, meta, description }: {
-        name?: string;
-        value?: any;
-        meta?: any;
-        description?: string;
-    }): Promise<any>;
+    createAsync({ acl, description, type, meta, name, value }: Partial<JsonBlob>): Promise<JsonBlob>;
+    /** Modify mutable properties of an existing JSONBlob, as identified by its unique token. */
+    updateAsync(token: string, { acl, description, meta, name, value }: Partial<JsonBlob>): Promise<JsonBlob>;
     /** Archive (soft-delete) an existing JSONBlob, as identified by its unique token. */
-    archiveAsync(token: string): Promise<any>;
+    archiveAsync(token: string): Promise<JsonBlob>;
 }

package/cmp/filter/FilterChooserModel.ts

@@ -7,10 +7,11 @@
 import {
     HoistModel,
     managed,
+    PersistableState,
     PersistenceProvider,
     PersistOptions,
-    PlainObject,
     TaskObserver,
+    Thunkable,
     XH
 } from '@xh/hoist/core';
 import {
@@ -26,9 +27,8 @@ import {
 import {CompoundFilterSpec, FieldFilterSpec, FilterLike} from '@xh/hoist/data/filter/Types';
 import {action, makeObservable, observable} from '@xh/hoist/mobx';
 import {wait} from '@xh/hoist/promise';
-import {throwIf, withDefault} from '@xh/hoist/utils/js';
+import {executeIfFunction, throwIf, withDefault} from '@xh/hoist/utils/js';
 import {createObservableRef} from '@xh/hoist/utils/react';
-import {ReactNode} from 'react';
 import {
     cloneDeep,
     compact,
@@ -39,13 +39,14 @@ import {
     isArray,
     isEmpty,
     isFinite,
-    isFunction,
+    isObject,
     isString,
     partition,
     sortBy,
     uniq,
     uniqBy
 } from 'lodash';
+import {ReactNode} from 'react';
 
 import {FilterChooserFieldSpec, FilterChooserFieldSpecConfig} from './FilterChooserFieldSpec';
 import {compoundFilterOption, fieldFilterOption, FilterChooserOption} from './impl/Option';
@@ -80,12 +81,12 @@ export interface FilterChooserConfig {
      * to produce the same. Note that FilterChooser currently can only edit and create a flat collection
      * of FieldFilters, to be 'AND'ed together.
      */
-    initialValue?: FilterChooserFilterLike | (() => FilterChooserFilterLike);
+    initialValue?: Thunkable<FilterChooserFilterLike>;
 
     /**
      * Initial favorites as an array of filter configurations, or a function to produce such an array.
      */
-    initialFavorites?: FilterChooserFilterLike[] | (() => FilterChooserFilterLike[]);
+    initialFavorites?: Thunkable<FilterChooserFilterLike[]>;
 
     /**
      * true to offer all field suggestions when the control is focused with an empty query,
@@ -131,9 +132,6 @@ export class FilterChooserModel extends HoistModel {
     maxTags: number;
     maxResults: number;
     introHelpText: ReactNode;
-
-    @managed provider: PersistenceProvider;
-    persistValue: boolean = false;
     persistFavorites: boolean = false;
 
     /** Tracks execution of filtering operation on bound object.*/
@@ -174,39 +172,12 @@ export class FilterChooserModel extends HoistModel {
         this.introHelpText = withDefault(introHelpText, this.getDefaultIntroHelpText());
         this.queryEngine = new QueryEngine(this);
 
-        let value = isFunction(initialValue) ? initialValue() : initialValue,
-            favorites = (isFunction(initialFavorites) ? initialFavorites() : initialFavorites).map(
-                f => parseFilter(f)
-            );
-
-        // Read state from provider -- fail gently
-        if (persistWith) {
-            try {
-                this.provider = PersistenceProvider.create({path: 'filterChooser', ...persistWith});
-                this.persistValue = persistWith.persistValue ?? true;
-                this.persistFavorites = persistWith.persistFavorites ?? true;
-
-                const state = this.provider.read();
-                if (this.persistValue && state?.value) {
-                    value = state.value;
-                }
-                if (this.persistFavorites && state?.favorites) {
-                    favorites = state.favorites.map(f => parseFilter(f));
-                }
+        this.setValueInternal(executeIfFunction(initialValue), false);
+        this.setFavorites(executeIfFunction(initialFavorites));
 
-                this.addReaction({
-                    track: () => this.persistState,
-                    run: state => this.provider.write(state)
-                });
-            } catch (e) {
-                this.logError(e);
-                XH.safeDestroy(this.provider);
-                this.provider = null;
-            }
-        }
+        if (persistWith) this.initPersist(persistWith);
 
-        this.setValue(value);
-        this.setFavorites(favorites);
+        this.updateSelectValueAndBind();
 
         if (bind) {
             this.addReaction({
@@ -231,73 +202,8 @@ export class FilterChooserModel extends HoistModel {
      *
      * Any other Filter is unsupported and will cause the control to show a placeholder error.
      */
-    @action
     setValue(rawValue: FilterLike) {
-        const {bind, maxTags} = this;
-        try {
-            const value = parseFilter(rawValue);
-            if (this.value?.equals(value)) return;
-
-            // 1) Ensure FilterChooser can handle the requested value.
-            const isValid = this.validateFilter(value),
-                displayFilters = isValid ? this.toDisplayFilters(value) : null;
-
-            this.unsupportedFilter = !isValid || (maxTags && displayFilters.length > maxTags);
-            if (this.unsupportedFilter) {
-                this.value = null;
-                this.selectOptions = null;
-                this.selectValue = null;
-                return;
-            }
-
-            // 2) Main path - filter has been validated as supported, set internal value.
-            this.logDebug('Setting value', value);
-            this.value = value as FilterChooserFilter;
-
-            // 3) Set props on select input needed to display
-            // Build list of options, used for displaying tags. We combine the needed
-            // options for the current filter tags with any previous ones to ensure
-            // tags are rendered correctly throughout the transition.
-            const newOptions = displayFilters.map(f => this.createFilterOption(f)),
-                previousOptions = this.selectOptions ?? [],
-                options = uniqBy([...newOptions, ...previousOptions], 'value');
-
-            this.selectOptions = !isEmpty(options) ? options : null;
-
-            // 4) Do the next steps asynchronously for UI responsiveness and to ensure the component
-            // is ready to render the tags correctly (after selectOptions set above).
-            wait()
-                .thenAction(() => {
-                    // No-op if we've already re-entered this method by the time this async routine runs.
-                    if (this.value !== value) {
-                        return;
-                    }
-
-                    this.selectValue = sortBy(
-                        displayFilters.map(f => JSON.stringify(f)),
-                        f => {
-                            const idx = this.selectValue?.indexOf(f);
-                            return isFinite(idx) && idx > -1 ? idx : displayFilters.length;
-                        }
-                    );
-
-                    // 5) Round-trip value to bound filter
-                    if (bind) {
-                        const filter = withFilterByTypes(bind.filter, value, [
-                            'FieldFilter',
-                            'CompoundFilter'
-                        ]);
-                        bind.setFilter(filter);
-                    }
-                })
-                .linkTo(this.filterTask);
-        } catch (e) {
-            this.logError('Failed to set value', e);
-            this.value = null;
-            this.selectOptions = null;
-            this.selectValue = null;
-            this.unsupportedFilter = true;
-        }
+        this.setValueInternal(rawValue, true);
     }
 
     //---------------------------
@@ -422,8 +328,8 @@ export class FilterChooserModel extends HoistModel {
     }
 
     @action
-    setFavorites(favorites: Filter[]) {
-        this.favorites = favorites.filter(this.validateFilter.bind(this));
+    setFavorites(favorites: FilterChooserFilterLike[]) {
+        this.favorites = favorites.map(parseFilter).filter(this.validateFilter.bind(this));
     }
 
     @action
@@ -445,16 +351,6 @@ export class FilterChooserModel extends HoistModel {
         return !!this.findFavorite(filter);
     }
 
-    //-------------------------
-    // Persistence handling
-    //-------------------------
-    get persistState() {
-        const ret: PlainObject = {};
-        if (this.persistValue) ret.value = this.value;
-        if (this.persistFavorites) ret.favorites = this.favorites;
-        return ret;
-    }
-
     //--------------------------------
     // FilterChooserFieldSpec handling
     //--------------------------------
@@ -507,22 +403,143 @@ export class FilterChooserModel extends HoistModel {
     getDefaultIntroHelpText(): string {
         return 'Select or enter a field name (below) or begin typing to match available field values.';
     }
+
+    // -------------------------------
+    // Implementation
+    // -------------------------------
+    private initPersist({
+        persistValue = true,
+        persistFavorites = true,
+        path = 'filterChooser',
+        ...rootPersistWith
+    }: FilterChooserPersistOptions) {
+        if (persistValue) {
+            const status = {initialized: false},
+                persistWith = isObject(persistValue) ? persistValue : rootPersistWith;
+            PersistenceProvider.create({
+                persistOptions: {
+                    path: `${path}.value`,
+                    ...persistWith
+                },
+                target: {
+                    getPersistableState: () => new PersistableState(this.value?.toJSON() ?? null),
+                    setPersistableState: ({value}) =>
+                        this.setValueInternal(value, status.initialized)
+                },
+                owner: this
+            });
+            status.initialized = true;
+        }
+
+        if (persistFavorites) {
+            const persistWith = isObject(persistFavorites) ? persistFavorites : rootPersistWith,
+                provider = PersistenceProvider.create({
+                    persistOptions: {
+                        path: `${path}.favorites`,
+                        ...persistWith
+                    },
+                    target: {
+                        getPersistableState: () =>
+                            new PersistableState(this.favorites.map(f => f.toJSON())),
+                        setPersistableState: ({value}) => this.setFavorites(value)
+                    },
+                    owner: this
+                });
+            if (provider) this.persistFavorites = true;
+        }
+    }
+
+    @action
+    private setValueInternal(rawValue: FilterLike, updateSelectValueAndBind: boolean) {
+        const {maxTags} = this;
+        try {
+            const value = parseFilter(rawValue);
+            if (this.value?.equals(value)) return;
+
+            // 1) Ensure FilterChooser can handle the requested value.
+            const isValid = this.validateFilter(value),
+                displayFilters = isValid ? this.toDisplayFilters(value) : null;
+
+            this.unsupportedFilter = !isValid || (maxTags && displayFilters.length > maxTags);
+            if (this.unsupportedFilter) {
+                this.value = null;
+                this.selectOptions = null;
+                this.selectValue = null;
+                return;
+            }
+
+            // 2) Main path - filter has been validated as supported, set internal value.
+            this.logDebug('Setting value', value);
+            this.value = value as FilterChooserFilter;
+
+            // 3) Set props on select input needed to display
+            // Build list of options, used for displaying tags. We combine the needed
+            // options for the current filter tags with any previous ones to ensure
+            // tags are rendered correctly throughout the transition.
+            const newOptions = displayFilters.map(f => this.createFilterOption(f)),
+                previousOptions = this.selectOptions ?? [],
+                options = uniqBy([...newOptions, ...previousOptions], 'value');
+
+            this.selectOptions = !isEmpty(options) ? options : null;
+
+            if (updateSelectValueAndBind) this.updateSelectValueAndBind(displayFilters);
+        } catch (e) {
+            this.logError('Failed to set value', e);
+            this.value = null;
+            this.selectOptions = null;
+            this.selectValue = null;
+            this.unsupportedFilter = true;
+        }
+    }
+
+    /**
+     * Update the select value and bind the filter to the bound model. Runs asynchronously after
+     * selectOptions are set to ensure the component is ready to render the tags correctly.
+     */
+    private updateSelectValueAndBind(displayFilters = this.toDisplayFilters(this.value)) {
+        const {bind, value} = this;
+        wait()
+            .thenAction(() => {
+                // No-op if we've already re-entered this method by the time this async routine runs.
+                if (this.value !== value) {
+                    return;
+                }
+
+                this.selectValue = sortBy(
+                    displayFilters.map(f => JSON.stringify(f)),
+                    f => {
+                        const idx = this.selectValue?.indexOf(f);
+                        return isFinite(idx) && idx > -1 ? idx : displayFilters.length;
+                    }
+                );
+
+                // Round-trip value to bound filter
+                if (bind) {
+                    const filter = withFilterByTypes(bind.filter, value, [
+                        'FieldFilter',
+                        'CompoundFilter'
+                    ]);
+                    bind.setFilter(filter);
+                }
+            })
+            .linkTo(this.filterTask);
+    }
 }
 
 interface FilterChooserPersistOptions extends PersistOptions {
-    /** True (default) to save value to state. */
-    persistValue?: boolean;
+    /** True (default) to include value or provide value-specific PersistOptions. */
+    persistValue?: boolean | PersistOptions;
 
-    /** True (default) to include favorites. */
-    persistFavorites?: boolean;
+    /** True (default) to include favorites or provide favorites-specific PersistOptions. */
+    persistFavorites?: boolean | PersistOptions;
 }
 
 /** A variant of {@link Filter} that excludes FunctionFilter (unsupported by FilterChooser). */
 export type FilterChooserFilter = CompoundFilter | FieldFilter;
+export type FilterChooserFilterSpec = CompoundFilterSpec | FieldFilterSpec;
 
 /** A variant of {@link FilterLike} that excludes FunctionFilters and FilterTestFn. */
 export type FilterChooserFilterLike =
-    | Filter
-    | CompoundFilterSpec
-    | FieldFilterSpec
+    | FilterChooserFilter
+    | FilterChooserFilterSpec
     | FilterChooserFilterLike[];

package/cmp/grid/Grid.ts

@@ -681,16 +681,8 @@ export class GridLocalModel extends HoistModel {
         }
 
         if (model.autosizeOptions.mode === 'managed') {
-            // If sizingMode different to autosizeState, autosize all columns...
-            if (model.autosizeState.sizingMode !== model.sizingMode) {
-                model.autosizeAsync();
-            } else {
-                // ...otherwise, only autosize columns that are not manually sized
-                const columns = model.columnState
-                    .filter(it => !it.manuallySized)
-                    .map(it => it.colId);
-                model.autosizeAsync({columns});
-            }
+            const columns = model.columnState.filter(it => !it.manuallySized).map(it => it.colId);
+            model.autosizeAsync({columns});
         }
 
         model.noteAgExpandStateChange();

package/cmp/grid/GridModel.ts

@@ -95,10 +95,9 @@ import {ReactNode} from 'react';
 import {GridAutosizeOptions} from './GridAutosizeOptions';
 import {GridContextMenuSpec} from './GridContextMenu';
 import {GridSorter, GridSorterLike} from './GridSorter';
-import {GridPersistenceModel} from './impl/GridPersistenceModel';
+import {initPersist} from './impl/InitPersist';
 import {managedRenderer} from './impl/Utils';
 import {
-    AutosizeState,
     ColChooserConfig,
     ColumnState,
     GridModelPersistOptions,
@@ -405,10 +404,13 @@ export class GridModel extends HoistModel {
     @observable.ref columns: Array<ColumnGroup | Column> = [];
     @observable.ref columnState: ColumnState[] = [];
     @observable.ref expandState: any = {};
-    @observable.ref autosizeState: AutosizeState = {};
     @observable.ref sortBy: GridSorter[] = [];
     @observable.ref groupBy: string[] = null;
 
+    get persistableColumnState(): ColumnState[] {
+        return this.cleanColumnState(this.columnState);
+    }
+
     @bindable showSummary: boolean | VSide = false;
     @bindable.ref emptyText: ReactNode;
     @bindable treeStyle: TreeStyle;
@@ -446,7 +448,6 @@ export class GridModel extends HoistModel {
     ];
 
     private _defaultState; // initial state provided to ctor - powers restoreDefaults().
-    @managed persistenceModel: GridPersistenceModel;
 
     /**
      * Is autosizing enabled on this grid?
@@ -599,7 +600,7 @@ export class GridModel extends HoistModel {
         this.colChooserModel = this.parseChooserModel(colChooserModel);
         this.selModel = this.parseSelModel(selModel);
         this.filterModel = this.parseFilterModel(filterModel);
-        this.persistenceModel = persistWith ? new GridPersistenceModel(this, persistWith) : null;
+        if (persistWith) initPersist(this, persistWith);
         this.experimental = this.parseExperimental(experimental);
         this.onKeyDown = onKeyDown;
         this.onRowClicked = onRowClicked;
@@ -649,7 +650,6 @@ export class GridModel extends HoistModel {
         this.setGroupBy(groupBy);
 
         this.filterModel?.clear();
-        this.persistenceModel?.clear();
 
         if (this.autosizeOptions.mode === 'managed') {
             await this.autosizeAsync();
@@ -1112,13 +1112,6 @@ export class GridModel extends HoistModel {
         }
     }
 
-    @action
-    setAutosizeState(autosizeState) {
-        if (!equal(this.autosizeState, autosizeState)) {
-            this.autosizeState = deepFreeze(autosizeState);
-        }
-    }
-
     noteColumnManuallySized(colId, width) {
         const col = this.findColumn(this.columns, colId);
         if (!width || !col || col.flex) return;
@@ -1126,12 +1119,6 @@ export class GridModel extends HoistModel {
         this.applyColumnStateChanges(colStateChanges);
     }
 
-    noteColumnsAutosized(colIds) {
-        const colStateChanges = castArray(colIds).map(colId => ({colId, manuallySized: false}));
-        this.applyColumnStateChanges(colStateChanges);
-        this.setAutosizeState({sizingMode: this.sizingMode});
-    }
-
     /**
      * This method will update the current column definition if it has changed.
      * Throws an exception if any of the columns provided in colStateChanges are not
@@ -1291,11 +1278,11 @@ export class GridModel extends HoistModel {
      * columns are also ignored unless {@link GridAutosizeOptions.includeHiddenColumns} has been
      * set to true.
      *
-     * @param options - optional overrides of this model's configured {@link autosizeOptions}.
+     * @param overrideOpts - optional overrides of this model's {@link GridAutosizeOptions}.
      */
     @logWithDebug
-    async autosizeAsync(options: GridAutosizeOptions = {}) {
-        options = {...this.autosizeOptions, ...options};
+    async autosizeAsync(overrideOpts: Omit<GridAutosizeOptions, 'mode'> = {}) {
+        const options = {...this.autosizeOptions, ...overrideOpts};
 
         if (options.mode === 'disabled') {
             return;
@@ -1305,16 +1292,16 @@ export class GridModel extends HoistModel {
         const {columns} = options;
         if (columns) options.fillMode = 'none'; // Fill makes sense only for the entire set.
 
-        let colIds,
-            includeColFn = col => true;
+        let colIds: string[],
+            includeColFn = (_: Column) => true;
         if (isFunction(columns)) {
-            includeColFn = columns as (col) => boolean;
+            includeColFn = columns as (col: Column) => boolean;
             colIds = this.columnState.map(it => it.colId);
         } else {
-            colIds = columns ?? this.columnState.map(it => it.colId);
+            colIds = columns ? castArray(columns) : this.columnState.map(it => it.colId);
         }
 
-        colIds = castArray(colIds).filter(id => {
+        colIds = colIds.filter(id => {
             if (!options.includeHiddenColumns && !this.isColumnVisible(id)) return false;
             const col = this.getColumn(id);
             return col && col.autosizable && !col.flex && includeColFn(col);
@@ -1327,7 +1314,7 @@ export class GridModel extends HoistModel {
 
     /**
      * Begin an inline editing session.
-     * @param recOrId - StoreRecord/ID to edit. If unspecified, the first selected StoreRecord
+     * @param record - StoreRecord/ID to edit. If unspecified, the first selected StoreRecord
      *      will be used, if any, or the first overall StoreRecord in the grid.
      * @param colId - ID of column on which to start editing. If unspecified, the first
      *      editable column will be used.
@@ -1472,7 +1459,7 @@ export class GridModel extends HoistModel {
         return new Column(config, this);
     }
 
-    private async autosizeColsInternalAsync(colIds, options) {
+    private async autosizeColsInternalAsync(colIds: string[], options: GridAutosizeOptions) {
         await this.whenReadyAsync();
         if (!this.isReady) return;
 
@@ -1485,7 +1472,6 @@ export class GridModel extends HoistModel {
 
         try {
             await XH.gridAutosizeService.autosizeAsync(this, colIds, options);
-            this.noteColumnsAutosized(colIds);
         } finally {
             if (showMask) {
                 await wait();
@@ -1616,7 +1602,8 @@ export class GridModel extends HoistModel {
             // Remove the width from any non-resizable column - we don't want to track those widths as
             // they are set programmatically (e.g. fixed / action columns), and saved state should not
             // conflict with any code-level updates to their widths.
-            if (!col.resizable) state = omit(state, 'width');
+            if (!col.resizable || !state.manuallySized) state = omit(state, 'width');
+            state = {...state, manuallySized: state.manuallySized ?? false};
 
             // Remove all metadata other than the id and the hidden state from hidden columns, to save
             // on space when storing user configs with large amounts of hidden fields.

package/cmp/grid/Types.ts

@@ -7,7 +7,7 @@
 
 import {IRowNode} from '@xh/hoist/kit/ag-grid';
 import {GridFilterFieldSpecConfig} from '@xh/hoist/cmp/grid/filter/GridFilterFieldSpec';
-import {HSide, PersistOptions, SizingMode, Some} from '@xh/hoist/core';
+import {HSide, PersistOptions, Some} from '@xh/hoist/core';
 import {Store, StoreRecord, View} from '@xh/hoist/data';
 import {ReactElement, ReactNode} from 'react';
 import {Column} from './columns/Column';
@@ -35,11 +35,6 @@ export interface ColumnState {
     pinned?: HSide;
 }
 
-export interface AutosizeState {
-    /** Sizing mode used last time the columns were autosized. */
-    sizingMode?: SizingMode;
-}
-
 /**
  * Comparator for custom grid group sorting, provided to GridModel.
  * @param groupAVal - first group value to be compared.
@@ -79,21 +74,12 @@ export type RowClassFn = (record: StoreRecord) => Some<string>;
 export type RowClassRuleFn = (agParams: RowClassParams) => boolean;
 
 export interface GridModelPersistOptions extends PersistOptions {
-    /** True to include column information (default true) */
-    persistColumns?: boolean;
-    /** True to include grouping information (default true) */
-    persistGrouping?: boolean;
-    /** True to include sorting information (default true) */
-    persistSort?: boolean;
-
-    /**
-     * Key to be used to identify location of legacy grid state from LocalStorage.
-     * This key will identify the pre-v35 location for grid state, and will be used
-     * as an initial source of grid state after an upgrade to v35.0.0 or greater.
-     * Defaults to the new value of 'key'.  If no legacy state is available at this
-     * location, the key is ignored.
-     */
-    legacyStateKey?: string;
+    /** True (default) to include column state or provide column-specific PersistOptions. */
+    persistColumns?: 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;
 }
 
 export interface GridFilterModelConfig {

package/cmp/grid/columns/Column.ts

@@ -478,7 +478,6 @@ export class Column {
     actions?: Array<RecordActionSpec | RecordAction>;
     actionsShowOnHoverOnly?: boolean;
     fieldSpec: FieldSpec;
-    manuallySized: boolean;
     omit: Thunkable<boolean>;
 
     gridModel: GridModel;