[Portable Dashboards] Remove Saved Object Class

src/plugins/controls/public/services/plugin_services.stub.ts

@@ -27,16 +27,15 @@ import { themeServiceFactory } from './theme/theme.story';
 import { registry as stubRegistry } from './plugin_services.story';
 
 export const providers: PluginServiceProviders<ControlsServices> = {
-  http: new PluginServiceProvider(httpServiceFactory),
+  controls: new PluginServiceProvider(controlsServiceFactory),
   data: new PluginServiceProvider(dataServiceFactory),
-  overlays: new PluginServiceProvider(overlaysServiceFactory),
   dataViews: new PluginServiceProvider(dataViewsServiceFactory),
+  http: new PluginServiceProvider(httpServiceFactory),
+  optionsList: new PluginServiceProvider(optionsListServiceFactory),
+  overlays: new PluginServiceProvider(overlaysServiceFactory),
   settings: new PluginServiceProvider(settingsServiceFactory),
-  unifiedSearch: new PluginServiceProvider(unifiedSearchServiceFactory),
   theme: new PluginServiceProvider(themeServiceFactory),
-
-  controls: new PluginServiceProvider(controlsServiceFactory),
-  optionsList: new PluginServiceProvider(optionsListServiceFactory),
+  unifiedSearch: new PluginServiceProvider(unifiedSearchServiceFactory),
 };
 
 export const pluginServices = new PluginServices<ControlsServices>();

src/plugins/controls/public/services/plugin_services.ts

@@ -30,16 +30,15 @@ export const providers: PluginServiceProviders<
   ControlsServices,
   KibanaPluginServiceParams<ControlsPluginStartDeps>
 > = {
-  http: new PluginServiceProvider(httpServiceFactory),
+  controls: new PluginServiceProvider(controlsServiceFactory),
   data: new PluginServiceProvider(dataServiceFactory),
-  unifiedSearch: new PluginServiceProvider(unifiedSearchServiceFactory),
-  overlays: new PluginServiceProvider(overlaysServiceFactory),
   dataViews: new PluginServiceProvider(dataViewsServiceFactory),
+  http: new PluginServiceProvider(httpServiceFactory),
+  optionsList: new PluginServiceProvider(optionsListServiceFactory, ['data', 'http']),
+  overlays: new PluginServiceProvider(overlaysServiceFactory),
   settings: new PluginServiceProvider(settingsServiceFactory),
   theme: new PluginServiceProvider(themeServiceFactory),
-
-  optionsList: new PluginServiceProvider(optionsListServiceFactory, ['data', 'http']),
-  controls: new PluginServiceProvider(controlsServiceFactory),
+  unifiedSearch: new PluginServiceProvider(unifiedSearchServiceFactory),
 };
 
 export const pluginServices = new PluginServices<ControlsServices>();

src/plugins/dashboard/public/application/hooks/use_dashboard_app_state.ts

@@ -16,12 +16,10 @@ import type { IKbnUrlStateStorage } from '@kbn/kibana-utils-plugin/public';
 
 import {
   diffDashboardState,
-  areTimeRangesEqual,
   syncDashboardUrlState,
   syncDashboardDataViews,
   buildDashboardContainer,
   syncDashboardFilterState,
-  areRefreshIntervalsEqual,
   syncDashboardContainerInput,
   tryDestroyDashboardContainer,
   loadDashboardHistoryLocationState,
@@ -244,7 +242,7 @@ export const useDashboardAppState = ({
        * Any time the redux state, or the last saved state changes, compare them, set the unsaved
        * changes state, and and push the unsaved changes to session storage.
        */
-      const { timefilter } = query.timefilter;
+
       const lastSavedSubscription = combineLatest([
         $onLastSavedStateChange,
         dashboardAppState.$onDashboardStateChange,
@@ -261,22 +259,12 @@ export const useDashboardAppState = ({
                 newState: current,
               }).then((unsavedChanges) => {
                 if (observer.closed) return;
-                const savedTimeChanged =
-                  lastSaved.timeRestore &&
-                  lastSaved.timeRange &&
-                  (!areTimeRangesEqual(lastSaved.timeRange, timefilter.getTime()) ||
-                    !areRefreshIntervalsEqual(
-                      lastSaved?.refreshInterval,
-                      timefilter.getRefreshInterval()
-                    ));
-
                 /**
                  * changes to the dashboard should only be considered 'unsaved changes' when
                  * editing the dashboard
                  */
                 const hasUnsavedChanges =
-                  current.viewMode === ViewMode.EDIT &&
-                  (Object.keys(unsavedChanges).length > 0 || savedTimeChanged);
+                  current.viewMode === ViewMode.EDIT && Object.keys(unsavedChanges).length > 0;
                 setDashboardAppState((s) => ({ ...s, hasUnsavedChanges }));
 
                 unsavedChanges.viewMode = current.viewMode; // always push view mode into session store.

src/plugins/dashboard/public/application/lib/diff_dashboard_state.ts

@@ -7,15 +7,24 @@
  */
 
 import fastIsEqual from 'fast-deep-equal';
-import { xor, omit, isEmpty } from 'lodash';
-
+import { xor, omit, isEmpty, pick } from 'lodash';
+
+import {
+  compareFilters,
+  COMPARE_ALL_OPTIONS,
+  type Filter,
+  isFilterPinned,
+  TimeRange,
+} from '@kbn/es-query';
+import { RefreshInterval } from '@kbn/data-plugin/common';
 import { IEmbeddable } from '@kbn/embeddable-plugin/public';
-import { compareFilters, COMPARE_ALL_OPTIONS, type Filter, isFilterPinned } from '@kbn/es-query';
 import { persistableControlGroupInputIsEqual } from '@kbn/controls-plugin/common';
 
 import { DashboardContainerInput } from '../..';
+import { areTimesEqual } from './filter_utils';
 import { DashboardPanelMap } from '../embeddable';
 import { DashboardOptions, DashboardState } from '../../types';
+import { pluginServices } from '../../services/plugin_services';
 
 const stateKeystoIgnore = [
   'expandedPanelId',
@@ -98,15 +107,67 @@ export const diffDashboardState = async ({
     newState.controlGroupInput
   );
 
+  const timeStatediff = getTimeSettingsAreEqual({
+    currentTimeRestore: newState.timeRestore,
+    lastSaved: { ...pick(originalState, ['timeRange', 'timeRestore', 'refreshInterval']) },
+  })
+    ? {}
+    : pick(newState, ['timeRange', 'timeRestore', 'refreshInterval']);
+
   return {
     ...commonStateDiff,
     ...(panelsAreEqual ? {} : { panels: newState.panels }),
     ...(filtersAreEqual ? {} : { filters: newState.filters }),
     ...(optionsAreEqual ? {} : { options: newState.options }),
     ...(controlGroupIsEqual ? {} : { controlGroupInput: newState.controlGroupInput }),
+    ...timeStatediff,
   };
 };
 
+interface TimeStateDiffArg {
+  timeRange?: TimeRange;
+  timeRestore?: boolean;
+  refreshInterval?: RefreshInterval;
+}
+
+export const getTimeSettingsAreEqual = ({
+  lastSaved,
+  currentTimeRestore,
+}: {
+  lastSaved?: TimeStateDiffArg;
+  currentTimeRestore?: boolean;
+}) => {
+  const {
+    data: {
+      query: {
+        timefilter: { timefilter },
+      },
+    },
+  } = pluginServices.getServices();
+
+  if (currentTimeRestore !== lastSaved?.timeRestore) return false;
+  if (!currentTimeRestore) return true;
+
+  const currentRange = timefilter.getTime();
+  const lastRange = lastSaved?.timeRange ?? timefilter.getTimeDefaults();
+  if (
+    !areTimesEqual(currentRange.from, lastRange.from) ||
+    !areTimesEqual(currentRange.to, lastRange.to)
+  ) {
+    return false;
+  }
+
+  const currentInterval = timefilter.getRefreshInterval();
+  const lastInterval = lastSaved?.refreshInterval ?? timefilter.getRefreshIntervalDefaults();
+  if (
+    currentInterval.pause !== lastInterval.pause ||
+    currentInterval.value !== lastInterval.value
+  ) {
+    return false;
+  }
+  return true;
+};
+
 const getFiltersAreEqual = (
   filtersA: Filter[],
   filtersB: Filter[],

src/plugins/dashboard/public/application/lib/filter_utils.ts

@@ -8,12 +8,7 @@
 
 import _ from 'lodash';
 import moment, { Moment } from 'moment';
-import type { Optional } from '@kbn/utility-types';
-import type { RefreshInterval } from '@kbn/data-plugin/public';
-import type { Filter, TimeRange } from '@kbn/es-query';
-
-type TimeRangeCompare = Optional<TimeRange>;
-type RefreshIntervalCompare = Optional<RefreshInterval>;
+import type { Filter } from '@kbn/es-query';
 
 /**
  * Converts the time to a utc formatted string. If the time is not valid (e.g. it might be in a relative format like
@@ -32,22 +27,6 @@ export const convertTimeToUTCString = (time?: string | Moment): undefined | stri
   }
 };
 
-export const areTimeRangesEqual = (rangeA: TimeRangeCompare, rangeB: TimeRangeCompare): boolean =>
-  areTimesEqual(rangeA.from, rangeB.from) && areTimesEqual(rangeA.to, rangeB.to);
-
-export const areRefreshIntervalsEqual = (
-  refreshA?: RefreshIntervalCompare,
-  refreshB?: RefreshIntervalCompare
-): boolean => refreshA?.pause === refreshB?.pause && refreshA?.value === refreshB?.value;
-
-/**
- * Compares the two times, making sure they are in both compared in string format. Absolute times
- * are sometimes stored as moment objects, but converted to strings when reloaded. Relative times are
- * strings that are not convertible to moment objects.
- * @param timeA {string|Moment}
- * @param timeB {string|Moment}
- * @returns {boolean}
- */
 export const areTimesEqual = (timeA?: string | Moment, timeB?: string | Moment) => {
   return convertTimeToUTCString(timeA) === convertTimeToUTCString(timeB);
 };

src/plugins/dashboard/public/application/lib/index.ts

@@ -6,19 +6,24 @@
  * Side Public License, v 1.
  */
 
-export * from './filter_utils';
+export {
+  areTimesEqual,
+  convertTimeToUTCString,
+  cleanFiltersForSerialize,
+  cleanFiltersForComparison,
+} from './filter_utils';
+export {
+  createSessionRestorationDataProvider,
+  enableDashboardSearchSessions,
+  getSearchSessionIdFromURL,
+  getSessionURLObservable,
+} from './dashboard_session_restoration';
 export { addHelpMenuToAppChrome } from './help_menu_util';
 export { diffDashboardState } from './diff_dashboard_state';
 export { syncDashboardUrlState } from './sync_dashboard_url_state';
 export { syncDashboardDataViews } from './sync_dashboard_data_views';
 export { syncDashboardFilterState } from './sync_dashboard_filter_state';
+export { stateToDashboardContainerInput } from './convert_dashboard_state';
 export { syncDashboardContainerInput } from './sync_dashboard_container_input';
 export { loadDashboardHistoryLocationState } from './load_dashboard_history_location_state';
 export { buildDashboardContainer, tryDestroyDashboardContainer } from './build_dashboard_container';
-export { stateToDashboardContainerInput } from './convert_dashboard_state';
-export {
-  createSessionRestorationDataProvider,
-  enableDashboardSearchSessions,
-  getSearchSessionIdFromURL,
-  getSessionURLObservable,
-} from './dashboard_session_restoration';

src/plugins/dashboard/public/application/state/dashboard_state_slice.ts

@@ -7,9 +7,11 @@
  */
 
 import { createSlice, PayloadAction } from '@reduxjs/toolkit';
-import { PersistableControlGroupInput } from '@kbn/controls-plugin/common';
+
 import { ViewMode } from '@kbn/embeddable-plugin/public';
+import { RefreshInterval } from '@kbn/data-plugin/common';
 import type { Filter, Query, TimeRange } from '@kbn/es-query';
+import { PersistableControlGroupInput } from '@kbn/controls-plugin/common';
 
 import { DashboardPanelMap } from '../../../common';
 import type { DashboardOptions, DashboardState } from '../../types';
@@ -34,11 +36,15 @@ export const dashboardStateSlice = createSlice({
         description: string;
         tags?: string[];
         timeRestore: boolean;
+        timeRange?: TimeRange;
+        refreshInterval?: RefreshInterval;
       }>
     ) => {
       state.title = action.payload.title;
       state.description = action.payload.description;
       state.timeRestore = action.payload.timeRestore;
+      state.timeRange = action.payload.timeRange;
+      state.refreshInterval = action.payload.refreshInterval;
       if (action.payload.tags) {
         state.tags = action.payload.tags;
       }