@skyux/data-manager 8.6.0 → 9.0.0-alpha.0

package/esm2022/lib/modules/data-manager/data-manager.service.mjs

@@ -0,0 +1,285 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, map, take, takeUntil, } from 'rxjs/operators';
+import { SkyDataManagerState } from './models/data-manager-state';
+import { SkyDataManagerStateChange } from './models/data-manager-state-change';
+import { SkyDataViewState } from './models/data-view-state';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/core";
+/**
+ * The data manager service provides ways for data views, toolbar items, and more to stay up to date
+ * with the active view ID, data manager config, registered views and their configs, and data state.
+ * There are methods to get current values, update values, and get subscriptions to the changing values.<br/> <br/>
+ * Provide this service at the component level for each instance of a data manager. Do not
+ * provide it at the module level or in `app-extras`. This allows multiple data
+ * managers to be used and self-contained.
+ */
+export class SkyDataManagerService {
+    #activeViewId;
+    #dataManagerConfig;
+    #views;
+    #dataStateChange;
+    #isInitialized;
+    #ngUnsubscribe;
+    #initSource;
+    #uiConfigService;
+    constructor(uiConfigService) {
+        this.viewkeeperClasses = new BehaviorSubject({});
+        this.#activeViewId = new ReplaySubject(1);
+        this.#dataManagerConfig = new BehaviorSubject({});
+        this.#views = new BehaviorSubject([]);
+        this.#dataStateChange = new ReplaySubject(1);
+        this.#ngUnsubscribe = new Subject();
+        this.#initSource = 'dataManagerServiceInit';
+        this.#uiConfigService = uiConfigService;
+    }
+    ngOnDestroy() {
+        this.#activeViewId.complete();
+        this.#dataManagerConfig.complete();
+        this.#views.complete();
+        this.#dataStateChange.complete();
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    /**
+     * Initializes the data manager with the given settings and sets `isInitialized` to `true`.
+     * This must be called for the data manager to render.
+     * @param args The initial active view ID, data manager config, and state to use for the data manager.
+     * If a settings key is provided, it checks for a saved data state in the SKY UI config service before using the default data state
+     * and saves any state changes to the service.
+     */
+    initDataManager(args) {
+        if (this.#isInitialized) {
+            console.warn('This data manager instance has already been initialized.');
+            return;
+        }
+        this.#isInitialized = true;
+        const defaultDataState = args.defaultDataState;
+        const settingsKey = args.settingsKey;
+        this.updateActiveViewId(args.activeViewId);
+        this.updateDataManagerConfig(args.dataManagerConfig);
+        if (settingsKey) {
+            this.#uiConfigService
+                .getConfig(settingsKey, defaultDataState.getStateOptions())
+                .pipe(take(1))
+                .subscribe((config) => {
+                this.updateDataState(new SkyDataManagerState(config), this.#initSource);
+            });
+        }
+        else {
+            this.updateDataState(defaultDataState, this.#initSource);
+        }
+        if (settingsKey) {
+            this.getDataStateUpdates(this.#initSource)
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((state) => {
+                this.#uiConfigService
+                    .setConfig(settingsKey, state.getStateOptions())
+                    .pipe(takeUntil(this.#ngUnsubscribe))
+                    .subscribe(
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
+                () => { }, (err) => {
+                    console.warn('Could not save data manager settings.');
+                    console.warn(err);
+                });
+            });
+        }
+    }
+    /**
+     * Initializes a view within the data manager. This must be called for each view for the views to appear within the data manager.
+     * @param viewConfig The SkyDataViewConfig settings for the view being registered.
+     */
+    initDataView(viewConfig) {
+        const currentViews = this.#views.value;
+        if (this.getViewById(viewConfig.id)) {
+            console.warn(`A data manager view with the id ${viewConfig.id} has already been initialized.`);
+            return;
+        }
+        currentViews.push(viewConfig);
+        this.#views.next(currentViews);
+        // When the initial activeViewId is set there are no views registered. We have to re-emit
+        // the activeId so the newly registered view is notified that it is active.
+        this.#activeViewId.pipe(take(1)).subscribe((id) => {
+            this.#activeViewId.next(id);
+        });
+        this.#dataStateChange
+            .pipe(take(1))
+            .subscribe((change) => {
+            const dataState = change.dataState;
+            const currentViewState = dataState.getViewStateById(viewConfig.id);
+            if (!currentViewState) {
+                const newViewState = new SkyDataViewState({ viewId: viewConfig.id });
+                // Ensure that the view state's available columns match with the view config. Also,
+                // add columns to the `displayedColumnIds` as long as they are not `initialHide`
+                if (viewConfig.columnOptions) {
+                    const columnIds = viewConfig.columnOptions.map((columnOptions) => {
+                        return columnOptions.id;
+                    });
+                    const displayedColumnIds = viewConfig.columnOptions
+                        .filter((columnOption) => {
+                        return !columnOption.initialHide;
+                    })
+                        .map((columnOption) => {
+                        return columnOption.id;
+                    });
+                    newViewState.columnIds = columnIds;
+                    newViewState.displayedColumnIds = displayedColumnIds;
+                }
+                const newDataState = dataState.addOrUpdateView(viewConfig.id, newViewState);
+                this.updateDataState(newDataState, this.#initSource);
+            }
+            else {
+                const currentAvailableColumnIds = viewConfig.columnOptions?.map((columnOptions) => {
+                    return columnOptions.id;
+                }) || [];
+                // Ensure that the view state's available columns match with the view config. Also,
+                // add new columns to the `displayedColumnIds` as long as they are not `initialHide`.
+                // We only add columns to `displayedColumnsIds` if we had previously tracked
+                // `columnIds` to avoid breaking changes.
+                if (currentViewState.columnIds.length > 0) {
+                    let newColumnIds = currentAvailableColumnIds?.filter((id) => currentViewState.columnIds.indexOf(id) < 0);
+                    newColumnIds = newColumnIds?.filter((columnId) => {
+                        return viewConfig.columnOptions?.find((columnOption) => columnOption.id === columnId && !columnOption.initialHide);
+                    });
+                    // Add the column IDs that now exist to the data manager state both as available
+                    // and as shown.
+                    currentViewState.displayedColumnIds =
+                        currentViewState.displayedColumnIds.concat(newColumnIds);
+                }
+                // Add the column IDs that now exist to the data manager state both as available
+                // and as shown.
+                currentViewState.columnIds = currentAvailableColumnIds;
+                const newDataState = dataState.addOrUpdateView(viewConfig.id, currentViewState);
+                this.updateDataState(newDataState, this.#initSource);
+            }
+        })
+            .unsubscribe();
+    }
+    /**
+     * Returns an observable of data state changes that views and other data manager entities can subscribe to.
+     * It excludes updates originating from the provided source. This allows subscribers to only respond to
+     * changes they did not create and helps prevent infinite loops of updates and responses.
+     * @param sourceId The ID of the entity subscribing to data state updates. This can be any value you choose
+     * but should be unique within the data manager instance and should also be used when that entity updates the state.
+     */
+    getDataStateUpdates(sourceId, updateFilter) {
+        // filter out events from the provided source and emit just the dataState
+        if (updateFilter) {
+            return this.#dataStateChange.pipe(filter((stateChange) => sourceId !== stateChange.source), map((stateChange) => stateChange.dataState), updateFilter.comparator
+                ? distinctUntilChanged(updateFilter.comparator)
+                : distinctUntilChanged(this.#getDefaultStateComparator(updateFilter.properties)));
+        }
+        else {
+            return this.#dataStateChange.pipe(filter((stateChange) => sourceId !== stateChange.source), map((stateChange) => stateChange.dataState));
+        }
+    }
+    /**
+     * Updates the data state and emits a new value to entities subscribed to data state changes.
+     * @param state The new `SkyDataManagerState` value.
+     * @param sourceId The ID of the entity updating the state. This can be any value you choose,
+     * but should be unique within the data manager instance and should also be used when that entity
+     * subscribes to state changes from `getDataStateUpdates`.
+     */
+    updateDataState(state, sourceId) {
+        const newState = new SkyDataManagerState(state.getStateOptions());
+        const newStateChange = new SkyDataManagerStateChange(newState, sourceId);
+        this.#dataStateChange.next(newStateChange);
+    }
+    /**
+     * Returns the current `SkyDataManagerConfig`.
+     */
+    getCurrentDataManagerConfig() {
+        return this.#dataManagerConfig.value;
+    }
+    /**
+     * Returns an observable of data manager config changes that views and other data manager entities can subscribe to.
+     */
+    getDataManagerConfigUpdates() {
+        return this.#dataManagerConfig;
+    }
+    /**
+     * Updates the data manager config and emits a new value to entities subscribed to data config changes.
+     * @param value The new `SkyDataManagerConfig` value.
+     */
+    updateDataManagerConfig(value) {
+        this.#dataManagerConfig.next(value);
+    }
+    /**
+     * Returns an observable of data view config changes that views and other data manager entities can subscribe to.
+     */
+    getDataViewsUpdates() {
+        return this.#views;
+    }
+    /**
+     * Returns an observable of the active view ID that views and other data manager entities can subscribe to.
+     */
+    getActiveViewIdUpdates() {
+        return this.#activeViewId;
+    }
+    /**
+     * Updates the active view ID. The data manager changes the displayed view.
+     * @param id The new active view ID.
+     */
+    updateActiveViewId(id) {
+        this.#activeViewId.next(id);
+    }
+    /**
+     * Returns the `SkyDataViewConfig` for the given view ID.
+     * @param viewId The ID of the view config to get.
+     */
+    getViewById(viewId) {
+        const currentViews = this.#views.value;
+        const viewConfig = currentViews.find((view) => view.id === viewId);
+        return viewConfig;
+    }
+    /**
+     * Updates the given view config. The registered view with the same ID is updated to the
+     * provided config, so include all properties regardless of whether they changed. If the
+     * view was not initialized already, no update happens.
+     * @param view The new `SkyDataViewConfig` containing all properties.
+     */
+    updateViewConfig(view) {
+        const currentViews = this.#views.value;
+        const existingViewIndex = currentViews.findIndex((currentView) => currentView.id === view.id);
+        if (existingViewIndex === -1) {
+            console.error('A view with the id {id} does not exist.', view.id);
+        }
+        else {
+            currentViews[existingViewIndex] = view;
+            this.#views.next(currentViews);
+        }
+    }
+    /**
+     * @internal
+     */
+    setViewkeeperClasses(viewId, classes) {
+        const viewkeeperClasses = this.viewkeeperClasses.value;
+        viewkeeperClasses[viewId] = classes;
+        this.viewkeeperClasses.next(viewkeeperClasses);
+    }
+    #filterDataStateProperties(state, properties) {
+        const stateProperties = state.getStateOptions();
+        const filteredStateProperties = {};
+        if (properties) {
+            for (const property of properties) {
+                if (property in stateProperties) {
+                    filteredStateProperties[property] = stateProperties[property];
+                }
+            }
+        }
+        return filteredStateProperties;
+    }
+    #getDefaultStateComparator(properties) {
+        return (state1, state2) => {
+            const filteredState1 = this.#filterDataStateProperties(state1, properties);
+            const filteredState2 = this.#filterDataStateProperties(state2, properties);
+            return JSON.stringify(filteredState1) === JSON.stringify(filteredState2);
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataManagerService, deps: [{ token: i1.SkyUIConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataManagerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SkyUIConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-manager.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/data-manager/src/lib/modules/data-manager/data-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { SkyUIConfigService } from '@skyux/core';\n\nimport { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';\nimport {\n  distinctUntilChanged,\n  filter,\n  map,\n  take,\n  takeUntil,\n} from 'rxjs/operators';\n\nimport { SkyDataManagerConfig } from './models/data-manager-config';\nimport { SkyDataManagerInitArgs } from './models/data-manager-init-args';\nimport { SkyDataManagerState } from './models/data-manager-state';\nimport { SkyDataManagerStateChange } from './models/data-manager-state-change';\nimport { SkyDataManagerStateOptions } from './models/data-manager-state-options';\nimport { SkyDataManagerStateUpdateFilterArgs } from './models/data-manager-state-update-filter-args';\nimport { SkyDataViewConfig } from './models/data-view-config';\nimport { SkyDataViewState } from './models/data-view-state';\n\n/**\n * The data manager service provides ways for data views, toolbar items, and more to stay up to date\n * with the active view ID, data manager config, registered views and their configs, and data state.\n * There are methods to get current values, update values, and get subscriptions to the changing values.<br/> <br/>\n * Provide this service at the component level for each instance of a data manager. Do not\n * provide it at the module level or in `app-extras`. This allows multiple data\n * managers to be used and self-contained.\n */\n@Injectable()\nexport class SkyDataManagerService implements OnDestroy {\n  public viewkeeperClasses = new BehaviorSubject<Record<string, string[]>>({});\n\n  readonly #activeViewId = new ReplaySubject<string>(1);\n  readonly #dataManagerConfig = new BehaviorSubject<SkyDataManagerConfig>({});\n  readonly #views = new BehaviorSubject<SkyDataViewConfig[]>([]);\n  readonly #dataStateChange = new ReplaySubject<SkyDataManagerStateChange>(1);\n\n  #isInitialized: boolean | undefined;\n  #ngUnsubscribe = new Subject<void>();\n  #initSource = 'dataManagerServiceInit';\n  #uiConfigService: SkyUIConfigService;\n\n  constructor(uiConfigService: SkyUIConfigService) {\n    this.#uiConfigService = uiConfigService;\n  }\n\n  public ngOnDestroy(): void {\n    this.#activeViewId.complete();\n    this.#dataManagerConfig.complete();\n    this.#views.complete();\n    this.#dataStateChange.complete();\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n  }\n\n  /**\n   * Initializes the data manager with the given settings and sets `isInitialized` to `true`.\n   * This must be called for the data manager to render.\n   * @param args The initial active view ID, data manager config, and state to use for the data manager.\n   * If a settings key is provided, it checks for a saved data state in the SKY UI config service before using the default data state\n   * and saves any state changes to the service.\n   */\n  public initDataManager(args: SkyDataManagerInitArgs): void {\n    if (this.#isInitialized) {\n      console.warn('This data manager instance has already been initialized.');\n      return;\n    }\n\n    this.#isInitialized = true;\n\n    const defaultDataState = args.defaultDataState;\n    const settingsKey = args.settingsKey;\n\n    this.updateActiveViewId(args.activeViewId);\n    this.updateDataManagerConfig(args.dataManagerConfig);\n\n    if (settingsKey) {\n      this.#uiConfigService\n        .getConfig(settingsKey, defaultDataState.getStateOptions())\n        .pipe(take(1))\n        .subscribe((config: SkyDataManagerStateOptions) => {\n          this.updateDataState(\n            new SkyDataManagerState(config),\n            this.#initSource\n          );\n        });\n    } else {\n      this.updateDataState(defaultDataState, this.#initSource);\n    }\n\n    if (settingsKey) {\n      this.getDataStateUpdates(this.#initSource)\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe((state: SkyDataManagerState) => {\n          this.#uiConfigService\n            .setConfig(settingsKey, state.getStateOptions())\n            .pipe(takeUntil(this.#ngUnsubscribe))\n            .subscribe(\n              // eslint-disable-next-line @typescript-eslint/no-empty-function\n              () => {},\n              (err) => {\n                console.warn('Could not save data manager settings.');\n                console.warn(err);\n              }\n            );\n        });\n    }\n  }\n\n  /**\n   * Initializes a view within the data manager. This must be called for each view for the views to appear within the data manager.\n   * @param viewConfig The SkyDataViewConfig settings for the view being registered.\n   */\n  public initDataView(viewConfig: SkyDataViewConfig): void {\n    const currentViews = this.#views.value;\n\n    if (this.getViewById(viewConfig.id)) {\n      console.warn(\n        `A data manager view with the id ${viewConfig.id} has already been initialized.`\n      );\n      return;\n    }\n\n    currentViews.push(viewConfig);\n    this.#views.next(currentViews);\n\n    // When the initial activeViewId is set there are no views registered. We have to re-emit\n    // the activeId so the newly registered view is notified that it is active.\n    this.#activeViewId.pipe(take(1)).subscribe((id) => {\n      this.#activeViewId.next(id);\n    });\n\n    this.#dataStateChange\n      .pipe(take(1))\n      .subscribe((change) => {\n        const dataState = change.dataState;\n        const currentViewState = dataState.getViewStateById(viewConfig.id);\n\n        if (!currentViewState) {\n          const newViewState = new SkyDataViewState({ viewId: viewConfig.id });\n\n          // Ensure that the view state's available columns match with the view config. Also,\n          // add columns to the `displayedColumnIds` as long as they are not `initialHide`\n          if (viewConfig.columnOptions) {\n            const columnIds = viewConfig.columnOptions.map((columnOptions) => {\n              return columnOptions.id;\n            });\n            const displayedColumnIds = viewConfig.columnOptions\n              .filter((columnOption) => {\n                return !columnOption.initialHide;\n              })\n              .map((columnOption) => {\n                return columnOption.id;\n              });\n\n            newViewState.columnIds = columnIds;\n            newViewState.displayedColumnIds = displayedColumnIds;\n          }\n          const newDataState = dataState.addOrUpdateView(\n            viewConfig.id,\n            newViewState\n          );\n\n          this.updateDataState(newDataState, this.#initSource);\n        } else {\n          const currentAvailableColumnIds =\n            viewConfig.columnOptions?.map((columnOptions) => {\n              return columnOptions.id;\n            }) || [];\n\n          // Ensure that the view state's available columns match with the view config. Also,\n          // add new columns to the `displayedColumnIds` as long as they are not `initialHide`.\n          // We only add columns to `displayedColumnsIds` if we had previously tracked\n          // `columnIds` to avoid breaking changes.\n          if (currentViewState.columnIds.length > 0) {\n            let newColumnIds = currentAvailableColumnIds?.filter(\n              (id) => currentViewState.columnIds.indexOf(id) < 0\n            );\n            newColumnIds = newColumnIds?.filter((columnId) => {\n              return viewConfig.columnOptions?.find(\n                (columnOption) =>\n                  columnOption.id === columnId && !columnOption.initialHide\n              );\n            });\n\n            // Add the column IDs that now exist to the data manager state both as available\n            // and as shown.\n            currentViewState.displayedColumnIds =\n              currentViewState.displayedColumnIds.concat(newColumnIds);\n          }\n          // Add the column IDs that now exist to the data manager state both as available\n          // and as shown.\n          currentViewState.columnIds = currentAvailableColumnIds;\n\n          const newDataState = dataState.addOrUpdateView(\n            viewConfig.id,\n            currentViewState\n          );\n\n          this.updateDataState(newDataState, this.#initSource);\n        }\n      })\n      .unsubscribe();\n  }\n\n  /**\n   * Returns an observable of data state changes that views and other data manager entities can subscribe to.\n   * It excludes updates originating from the provided source. This allows subscribers to only respond to\n   * changes they did not create and helps prevent infinite loops of updates and responses.\n   * @param sourceId The ID of the entity subscribing to data state updates. This can be any value you choose\n   * but should be unique within the data manager instance and should also be used when that entity updates the state.\n   */\n  public getDataStateUpdates(\n    sourceId: string,\n    updateFilter?: SkyDataManagerStateUpdateFilterArgs\n  ): Observable<SkyDataManagerState> {\n    // filter out events from the provided source and emit just the dataState\n    if (updateFilter) {\n      return this.#dataStateChange.pipe(\n        filter((stateChange) => sourceId !== stateChange.source),\n        map((stateChange) => stateChange.dataState),\n        updateFilter.comparator\n          ? distinctUntilChanged(updateFilter.comparator)\n          : distinctUntilChanged(\n              this.#getDefaultStateComparator(\n                updateFilter.properties as (keyof SkyDataManagerStateOptions)[]\n              )\n            )\n      );\n    } else {\n      return this.#dataStateChange.pipe(\n        filter((stateChange) => sourceId !== stateChange.source),\n        map((stateChange) => stateChange.dataState)\n      );\n    }\n  }\n\n  /**\n   * Updates the data state and emits a new value to entities subscribed to data state changes.\n   * @param state The new `SkyDataManagerState` value.\n   * @param sourceId The ID of the entity updating the state. This can be any value you choose,\n   * but should be unique within the data manager instance and should also be used when that entity\n   * subscribes to state changes from `getDataStateUpdates`.\n   */\n  public updateDataState(state: SkyDataManagerState, sourceId: string): void {\n    const newState = new SkyDataManagerState(state.getStateOptions());\n    const newStateChange = new SkyDataManagerStateChange(newState, sourceId);\n\n    this.#dataStateChange.next(newStateChange);\n  }\n\n  /**\n   * Returns the current `SkyDataManagerConfig`.\n   */\n  public getCurrentDataManagerConfig(): SkyDataManagerConfig {\n    return this.#dataManagerConfig.value;\n  }\n\n  /**\n   * Returns an observable of data manager config changes that views and other data manager entities can subscribe to.\n   */\n  public getDataManagerConfigUpdates(): Observable<SkyDataManagerConfig> {\n    return this.#dataManagerConfig;\n  }\n\n  /**\n   * Updates the data manager config and emits a new value to entities subscribed to data config changes.\n   * @param value The new `SkyDataManagerConfig` value.\n   */\n  public updateDataManagerConfig(value: SkyDataManagerConfig): void {\n    this.#dataManagerConfig.next(value);\n  }\n\n  /**\n   * Returns an observable of data view config changes that views and other data manager entities can subscribe to.\n   */\n  public getDataViewsUpdates(): Observable<SkyDataViewConfig[]> {\n    return this.#views;\n  }\n\n  /**\n   * Returns an observable of the active view ID that views and other data manager entities can subscribe to.\n   */\n  public getActiveViewIdUpdates(): Observable<string> {\n    return this.#activeViewId;\n  }\n\n  /**\n   * Updates the active view ID. The data manager changes the displayed view.\n   * @param id The new active view ID.\n   */\n  public updateActiveViewId(id: string): void {\n    this.#activeViewId.next(id);\n  }\n\n  /**\n   * Returns the `SkyDataViewConfig` for the given view ID.\n   * @param viewId The ID of the view config to get.\n   */\n  public getViewById(viewId: string): SkyDataViewConfig | undefined {\n    const currentViews: SkyDataViewConfig[] = this.#views.value;\n    const viewConfig: SkyDataViewConfig | undefined = currentViews.find(\n      (view) => view.id === viewId\n    );\n\n    return viewConfig;\n  }\n\n  /**\n   * Updates the given view config. The registered view with the same ID is updated to the\n   * provided config, so include all properties regardless of whether they changed. If the\n   * view was not initialized already, no update happens.\n   * @param view The new `SkyDataViewConfig` containing all properties.\n   */\n  public updateViewConfig(view: SkyDataViewConfig): void {\n    const currentViews: SkyDataViewConfig[] = this.#views.value;\n    const existingViewIndex = currentViews.findIndex(\n      (currentView) => currentView.id === view.id\n    );\n\n    if (existingViewIndex === -1) {\n      console.error('A view with the id {id} does not exist.', view.id);\n    } else {\n      currentViews[existingViewIndex] = view;\n      this.#views.next(currentViews);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public setViewkeeperClasses(viewId: string, classes: string[]): void {\n    const viewkeeperClasses = this.viewkeeperClasses.value;\n    viewkeeperClasses[viewId] = classes;\n\n    this.viewkeeperClasses.next(viewkeeperClasses);\n  }\n\n  #filterDataStateProperties(\n    state: SkyDataManagerState,\n    properties: (keyof SkyDataManagerStateOptions)[] | undefined\n  ): Record<string, unknown> {\n    const stateProperties = state.getStateOptions();\n    const filteredStateProperties: Record<string, unknown> = {};\n\n    if (properties) {\n      for (const property of properties) {\n        if (property in stateProperties) {\n          filteredStateProperties[property] = stateProperties[property];\n        }\n      }\n    }\n\n    return filteredStateProperties;\n  }\n\n  #getDefaultStateComparator(\n    properties: (keyof SkyDataManagerStateOptions)[] | undefined\n  ): (state1: SkyDataManagerState, state2: SkyDataManagerState) => boolean {\n    return (\n      state1: SkyDataManagerState,\n      state2: SkyDataManagerState\n    ): boolean => {\n      const filteredState1 = this.#filterDataStateProperties(\n        state1,\n        properties\n      );\n      const filteredState2 = this.#filterDataStateProperties(\n        state2,\n        properties\n      );\n      return JSON.stringify(filteredState1) === JSON.stringify(filteredState2);\n    };\n  }\n}\n"]}

package/esm2022/lib/modules/data-manager/data-view.component.mjs

@@ -0,0 +1,49 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./data-manager.service";
+import * as i2 from "@angular/common";
+/**
+ * A data view is rendered within a data manager component.
+ * It can subscribe to data state changes from `SkyDataManagerService` and apply the filters,
+ * search text, and more to the data it displays.
+ */
+export class SkyDataViewComponent {
+    get isActive() {
+        return this.#_isActive;
+    }
+    set isActive(value) {
+        this.#_isActive = value;
+        this.#changeDetector.markForCheck();
+    }
+    #_isActive = false;
+    #ngUnsubscribe = new Subject();
+    #dataManagerService;
+    #changeDetector;
+    constructor(dataManagerService, changeDetector) {
+        this.#dataManagerService = dataManagerService;
+        this.#changeDetector = changeDetector;
+    }
+    ngOnInit() {
+        this.#dataManagerService
+            .getActiveViewIdUpdates()
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((activeViewId) => {
+            this.isActive = this.viewId === activeViewId;
+        });
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataViewComponent, deps: [{ token: i1.SkyDataManagerService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: SkyDataViewComponent, selector: "sky-data-view", inputs: { viewId: "viewId" }, ngImport: i0, template: "<ng-container *ngIf=\"isActive\">\n  <ng-content></ng-content>\n</ng-container>\n", dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-data-view', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"isActive\">\n  <ng-content></ng-content>\n</ng-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.SkyDataManagerService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { viewId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/shared/sky-data-manager-resources.module.mjs

@@ -0,0 +1,60 @@
+/**
+ * NOTICE: DO NOT MODIFY THIS FILE!
+ * The contents of this file were automatically generated by
+ * the 'ng generate @skyux/i18n:lib-resources-module lib/modules/shared/sky-data-manager' schematic.
+ * To update this file, simply rerun the command.
+ */
+import { NgModule } from '@angular/core';
+import { SKY_LIB_RESOURCES_PROVIDERS, SkyI18nModule, getLibStringForLocale, } from '@skyux/i18n';
+import * as i0 from "@angular/core";
+const RESOURCES = {
+    'EN-US': {
+        skyux_data_manager_column_picker_title: {
+            message: 'Choose columns to show in the list',
+        },
+        skyux_data_manager_apply_changes_button_title: { message: 'Apply changes' },
+        skyux_data_manager_cancel_button_title: { message: 'Cancel' },
+        skyux_data_manager_select_all_button_title: { message: 'Select all' },
+        skyux_data_manager_clear_all_button_title: { message: 'Clear all' },
+        skyux_data_manager_show_selected_option_title: {
+            message: 'Show only selected items',
+        },
+        skyux_data_manager_columns_button_title: { message: 'Columns' },
+        skyux_data_manager_select_column_status_indicator_title: {
+            message: 'Select at least one column.',
+        },
+    },
+};
+export class SkyDataManagerResourcesProvider {
+    getString(localeInfo, name) {
+        return getLibStringForLocale(RESOURCES, localeInfo.locale, name);
+    }
+}
+/**
+ * Import into any component library module that needs to use resource strings.
+ */
+export class SkyDataManagerResourcesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataManagerResourcesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyDataManagerResourcesModule, exports: [SkyI18nModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataManagerResourcesModule, providers: [
+            {
+                provide: SKY_LIB_RESOURCES_PROVIDERS,
+                useClass: SkyDataManagerResourcesProvider,
+                multi: true,
+            },
+        ], imports: [SkyI18nModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDataManagerResourcesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [SkyI18nModule],
+                    providers: [
+                        {
+                            provide: SKY_LIB_RESOURCES_PROVIDERS,
+                            useClass: SkyDataManagerResourcesProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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