@caperjs/core 0.1.0

package/src/plugins/AssetsPlugin.ts

@@ -0,0 +1,407 @@
+import type { AssetsPreferences, ResolvedAsset, UnresolvedAsset } from 'pixi.js';
+import { Assets } from 'pixi.js';
+import type { IScene } from '../display';
+import { Signal } from '../signals';
+import {
+  AssetLike,
+  AssetLoadingOptions,
+  AssetTypes,
+  BundleTypes,
+  CaperEvent,
+  isDev,
+  SceneImportListItem,
+} from '../utils';
+import type { IPlugin } from './Plugin';
+import { Plugin } from './Plugin';
+
+export interface IAssetsPlugin extends IPlugin {
+  onLoadStart: Signal<() => void>;
+  onLoadProgress: Signal<(progress: number) => void>;
+  onLoadComplete: Signal<() => void>;
+
+  onLoadRequiredStart: Signal<() => void>;
+  onLoadRequiredProgress: Signal<(progress: number) => void>;
+  onLoadRequiredComplete: Signal<() => void>;
+
+  onBackgroundLoadStart: Signal<() => void>;
+  onBackgroundAssetLoaded: Signal<(asset: string) => void>;
+  onBackgroundBundlesLoaded: Signal<(bundles: BundleTypes) => void>;
+
+  webStartEvent: Event;
+  webProgressEvent: CustomEvent<{ progress: number }>;
+  webCompleteEvent: Event;
+
+  webRequiredStartEvent: Event;
+  webRequiredProgressEvent: CustomEvent<{ progress: number }>;
+  webRequiredCompleteEvent: Event;
+
+  loadAssets(
+    assets: string | string[] | UnresolvedAsset | UnresolvedAsset[] | AssetLike | AssetLike[],
+    reportProgress?: boolean,
+  ): Promise<void>;
+
+  loadBundles(bundle: BundleTypes, reportProgress?: boolean): Promise<void>;
+
+  loadSceneAssets(scene: IScene | SceneImportListItem<any>, background?: boolean): Promise<void>;
+
+  unloadSceneAssets(scene: IScene | SceneImportListItem<any>): Promise<void>;
+
+  loadRequired(): Promise<void>;
+
+  loadBackground(): void;
+}
+
+const detaultAssetPreferences: Partial<AssetsPreferences> = {
+  preferWorkers: !isDev,
+  crossOrigin: 'anonymous',
+};
+
+function addParseAsGraphicsContext(asset: string | UnresolvedAsset): string | UnresolvedAsset {
+  if (typeof asset === 'string') {
+    if (!asset?.includes('.svg')) {
+      return asset;
+    }
+    asset = { src: asset };
+  } else {
+    if (Array.isArray(asset.src) || !asset.src?.includes('.svg')) {
+      return asset;
+    }
+  }
+  if (!asset.data) {
+    asset.data = {};
+  }
+  asset.data.parseAsGraphicsContext = true;
+  return asset;
+}
+
+function getAssetList(assets: AssetTypes): UnresolvedAsset[] | string[] {
+  if (!Array.isArray(assets)) {
+    assets = [assets];
+  }
+  return assets.map((asset: string | UnresolvedAsset | AssetLike) => {
+    if (typeof asset === 'string') {
+      return addParseAsGraphicsContext(asset);
+    } else if (typeof asset === 'object') {
+      let alias: string | string[] = (asset?.src as string | string[]) || [];
+      if (!Array.isArray(alias)) {
+        alias = [alias];
+      }
+      if (asset.ext) {
+        if (asset.src && !Array.isArray(asset.src)) {
+          alias.push(asset.src as string);
+          asset.src = [asset.src];
+        }
+        asset.src = (asset.src as string[]).map((src: string) => {
+          return `${src}.${asset.ext}`;
+        });
+        asset.alias = [...alias, ...(asset.src as string[])].filter(Boolean);
+      } else {
+        addParseAsGraphicsContext(asset);
+      }
+      return asset;
+    }
+  });
+}
+
+export class AssetsPlugin extends Plugin<AssetLoadingOptions> implements IAssetsPlugin {
+  public readonly id: string = 'assets';
+  public onLoadStart: Signal<() => void> = new Signal();
+  public onLoadProgress: Signal<(progress: number) => void> = new Signal();
+  public onLoadComplete: Signal<() => void> = new Signal();
+  // required loading signals
+  public onLoadRequiredStart: Signal<() => void> = new Signal();
+  public onLoadRequiredProgress: Signal<(progress: number) => void> = new Signal();
+  public onLoadRequiredComplete: Signal<() => void> = new Signal();
+
+  public onBackgroundLoadStart: Signal<() => void> = new Signal();
+  public onBackgroundAssetLoaded: Signal<(asset: string) => void> = new Signal();
+  public onBackgroundBundlesLoaded: Signal<(bundles: BundleTypes) => void> = new Signal();
+
+  private _loadedBundles: Set<string> = new Set();
+  private _loadedAssets: Set<string | UnresolvedAsset> = new Set();
+
+  private _required: { assets?: AssetTypes; bundles?: BundleTypes } = {};
+  private _background: { assets?: AssetTypes; bundles?: BundleTypes } = {};
+
+  private _isLoadingRequired: boolean = false;
+
+  public webRequiredStartEvent: Event = new Event(CaperEvent.REQUIRED_ASSETS_START, {
+    bubbles: true,
+    cancelable: false,
+  });
+  public webRequiredProgressEvent: CustomEvent<{ progress: number }> = new CustomEvent<{ progress: number }>(
+    CaperEvent.REQUIRED_ASSETS_PROGRESS,
+    {
+      bubbles: true,
+      cancelable: false,
+      detail: {
+        progress: 0,
+      },
+    },
+  );
+  public webRequiredCompleteEvent: Event = new Event(CaperEvent.REQUIRED_ASSETS_COMPLETE, {
+    bubbles: true,
+    cancelable: false,
+  });
+
+  public webStartEvent: Event = new Event(CaperEvent.ASSETS_START, {
+    bubbles: true,
+    cancelable: false,
+  });
+  public webProgressEvent: CustomEvent<{ progress: number }> = new CustomEvent<{ progress: number }>(
+    CaperEvent.ASSETS_PROGRESS,
+    {
+      bubbles: true,
+      cancelable: false,
+      detail: {
+        progress: 0,
+      },
+    },
+  );
+  public webCompleteEvent: Event = new Event(CaperEvent.ASSETS_COMPLETE, {
+    bubbles: true,
+    cancelable: false,
+  });
+
+  public initialize(options?: AssetLoadingOptions): Promise<void> | void {
+    if (options?.preload) {
+      this._required = options.preload;
+    }
+    if (options?.background) {
+      this._background = options.background;
+    }
+    Assets.setPreferences({ ...detaultAssetPreferences, ...options?.assetPreferences });
+  }
+
+  public async loadRequired() {
+    this._isLoadingRequired = true;
+    this._handleLoadStart();
+    this._handleLoadProgress(0);
+    if (this._required) {
+      if (this._required.assets) {
+        await Assets.load(getAssetList(this._required.assets), this._handleLoadProgress);
+      }
+      if (this._required.bundles) {
+        let bundles = this._required.bundles;
+        if (!Array.isArray(bundles)) {
+          bundles = [bundles];
+        }
+        bundles = bundles.filter((bundle) => !this._isBundleLoaded(bundle));
+        await Assets.loadBundle(this._required.bundles, this._handleLoadProgress);
+      }
+    }
+    this._handleLoadComplete();
+    this._isLoadingRequired = false;
+    return Promise.resolve();
+  }
+
+  public loadBackground() {
+    this.onBackgroundLoadStart.emit();
+    if (this._background) {
+      if (this._background.assets) {
+        const list = getAssetList(this._background.assets);
+        list.forEach((asset) => {
+          if ((asset as UnresolvedAsset)?.src) {
+            const src = (asset as UnresolvedAsset).src as string[];
+            if (src) {
+              return Assets.backgroundLoad(src);
+            }
+          }
+          return Assets.backgroundLoad(asset as string).then(() => {
+            this.onBackgroundAssetLoaded.emit(asset as string);
+          });
+        });
+      }
+      if (this._background.bundles) {
+        void Assets.backgroundLoadBundle(this._background.bundles).then(() => {
+          this.onBackgroundBundlesLoaded.emit(this._background.bundles as BundleTypes);
+        });
+      }
+    }
+  }
+
+  public async loadAssets(assets: AssetTypes, reportProgress: boolean = true) {
+    assets = getAssetList(assets);
+    await Assets.load(assets, reportProgress ? this._handleLoadProgress : undefined);
+    this._markAssetsLoaded(assets as UnresolvedAsset[] | string[]);
+    return Promise.resolve();
+  }
+
+  public async loadBundles(bundles: BundleTypes, reportProgress: boolean = true) {
+    await Assets.loadBundle(bundles, reportProgress ? this._handleLoadProgress : undefined);
+    this._markBundlesLoaded(bundles);
+    return Promise.resolve();
+  }
+
+  public async unloadSceneAssets(scene: IScene | SceneImportListItem<any>) {
+    if (scene.assets?.preload?.assets) {
+      const assets = getAssetList(scene.assets.preload.assets);
+      Assets.unload(assets as ResolvedAsset[] | string[]).then(() => {
+        // Logger.log('assets unloaded');
+        this._markAssetsUnloaded(assets);
+      });
+    }
+    if (scene.assets?.preload?.bundles) {
+      const bundles = scene.assets.preload.bundles;
+      void Assets.unloadBundle(bundles).then(() => {
+        this._markBundlesUnloaded(bundles);
+      });
+    }
+    return Promise.resolve();
+  }
+
+  public async loadSceneAssets(scene: IScene | SceneImportListItem<any>, background = false) {
+    if (background) {
+      if (scene.assets?.background) {
+        if (scene.assets.background.assets) {
+          const assets = getAssetList(scene.assets.background.assets);
+          const filteredAssets = assets.filter((asset: string | UnresolvedAsset) => !this._isAssetLoaded(asset));
+          if (filteredAssets.length) {
+            filteredAssets.forEach((asset) => {
+              if ((asset as UnresolvedAsset)?.src) {
+                const src = (asset as UnresolvedAsset).src as string[];
+                if (src) {
+                  return Assets.backgroundLoad(src);
+                }
+              }
+              return Assets.backgroundLoad(asset as string);
+            });
+          }
+        }
+        if (scene.assets.background.bundles) {
+          let bundles = Array.isArray(scene.assets.background.bundles)
+            ? scene.assets.background.bundles
+            : [scene.assets.background.bundles];
+          bundles = bundles.filter((bundle) => !this._isBundleLoaded(bundle));
+          if (bundles.length) {
+            void Assets.backgroundLoadBundle(bundles);
+          }
+        }
+      }
+    } else {
+      this._handleLoadStart();
+      this._handleLoadProgress(0);
+      if (scene.assets?.preload?.assets) {
+        const assets = getAssetList(scene.assets.preload.assets);
+        const filteredAssets = assets.filter((asset) => !this._isAssetLoaded(asset));
+        if (filteredAssets.length) {
+          await Assets.load(filteredAssets, this._handleLoadProgress);
+          this._markAssetsLoaded(assets);
+        }
+      }
+      if (scene.assets?.preload?.bundles) {
+        let bundles: string[] = Array.isArray(scene.assets.preload.bundles)
+          ? scene.assets.preload.bundles
+          : [scene.assets.preload.bundles];
+        bundles = bundles.filter((bundle) => !this._isBundleLoaded(bundle));
+        if (bundles.length) {
+          await Assets.loadBundle(bundles, this._handleLoadProgress);
+          this._markBundlesLoaded(bundles);
+        }
+      }
+      this._handleLoadComplete();
+    }
+  }
+
+  protected getCoreFunctions(): string[] {
+    return ['loadSceneAssets', 'unloadSceneAssets', 'loadAssets', 'loadBundles', 'loadRequired'];
+  }
+
+  protected getCoreSignals(): string[] {
+    return [
+      'onLoadStart',
+      'onLoadProgress',
+      'onLoadComplete',
+      'onBackgroundLoadStart',
+      'onBackgroundAssetLoaded',
+      'onBackgroundBundlesLoaded',
+      'onLoadRequiredStart',
+      'onLoadRequiredProgress',
+      'onLoadRequiredComplete',
+    ];
+  }
+
+  private _isAssetLoaded(alias: string | UnresolvedAsset) {
+    return this._loadedAssets.has(alias);
+  }
+
+  private _isBundleLoaded(alias: string) {
+    return this._loadedBundles.has(alias);
+  }
+
+  private _markAssetsLoaded(urls: UnresolvedAsset[] | string[]) {
+    urls.forEach((url) => {
+      this._loadedAssets.add(url);
+    });
+  }
+
+  private _markBundlesLoaded(aliases: string[] | string) {
+    if (!Array.isArray(aliases)) {
+      aliases = [aliases];
+    }
+    aliases.forEach((alias) => {
+      this._loadedBundles.add(alias);
+    });
+  }
+
+  private _markAssetsUnloaded(urls: string[] | string | UnresolvedAsset | UnresolvedAsset[]) {
+    if (!Array.isArray(urls)) {
+      urls = [urls];
+    }
+    urls.forEach((url: string | UnresolvedAsset) => {
+      this._loadedAssets.delete(url);
+    });
+  }
+
+  private _markBundlesUnloaded(aliases: string[] | string) {
+    if (!Array.isArray(aliases)) {
+      aliases = [aliases];
+    }
+    aliases.forEach((alias) => {
+      this._loadedBundles.delete(alias);
+    });
+  }
+
+  private _handleLoadStart() {
+    this.onLoadStart.emit();
+    this.dispatchWebEvent(this.webStartEvent);
+    if (this._isLoadingRequired) {
+      this.onLoadRequiredStart.emit();
+      this.dispatchWebEvent(this.webRequiredStartEvent);
+    }
+  }
+
+  private _handleLoadProgress(progress: number) {
+    this.onLoadProgress.emit(progress);
+    this.dispatchWebEvent(this.webProgressEvent, { progress });
+    if (this._isLoadingRequired) {
+      this.onLoadRequiredProgress.emit(progress);
+      this.dispatchWebEvent(this.webRequiredProgressEvent, { progress });
+    }
+  }
+
+  private _handleLoadComplete() {
+    this._handleLoadProgress(1);
+    this.onLoadComplete.emit();
+    this.dispatchWebEvent(this.webCompleteEvent);
+
+    if (this._isLoadingRequired) {
+      this.onLoadRequiredComplete.emit();
+      this.dispatchWebEvent(this.webRequiredCompleteEvent);
+    }
+  }
+
+  private dispatchWebEvent(event: Event | CustomEvent, detail?: any) {
+    if (detail) {
+      for (const key in detail) {
+        const e = event as CustomEvent<any>;
+        e.detail[key] = detail[key];
+      }
+    }
+    try {
+      this.app.canvas.dispatchEvent(event);
+    } catch (error: any) {
+      throw new Error('Error dispatching web event', { cause: error });
+    }
+  }
+}

package/src/plugins/DataAdapter.ts

@@ -0,0 +1,259 @@
+import { Signal } from '../signals';
+import { AppTypeOverrides, deepMerge, DeepPartial } from '../utils';
+import { Plugin } from './Plugin';
+
+export type DataSchema = {
+  [key: string]: any;
+};
+
+/**
+ * Interface for the options of the DataAdapter.
+ */
+export interface IDataAdapterOptions {
+  initial: Partial<AppTypeOverrides['Data']>;
+  /**
+   * The namespace to use for the keys in local storage.
+   */
+  namespace: string;
+  /**
+   * Whether to override the data with the data from local storage.
+   */
+  overrideWithLocalStorage: boolean;
+  /**
+   * Whether to backup all data to local storage.
+   */
+  backupAll: boolean;
+  /**
+   * The keys to backup to local storage.
+   */
+  backupKeys: Array<keyof AppTypeOverrides['Data']>;
+}
+
+export interface DataChangeSignalDetail {
+  key?: any;
+  value?: any;
+  restore?: boolean;
+  clear?: boolean;
+}
+
+type DataAdapterType = AppTypeOverrides['Data'];
+
+export interface IDataAdapter {
+  get(): DataAdapterType;
+  get<K extends keyof DataAdapterType>(key: K): DataAdapterType[K] | undefined;
+  set<K extends keyof DataAdapterType>(key: K, data: DataAdapterType[K]): DataAdapterType;
+  set(data: DeepPartial<DataAdapterType>, merge?: boolean): DataAdapterType;
+  clear(): void;
+  clear<K extends keyof DataAdapterType>(key: K): void;
+  increment<
+    K extends keyof DataAdapterType &
+      { [P in keyof DataAdapterType]: DataAdapterType[P] extends number ? P : never }[keyof DataAdapterType],
+  >(
+    key: K,
+    amount?: number,
+  ): DataAdapterType[K];
+  concat<
+    K extends keyof DataAdapterType &
+      { [P in keyof DataAdapterType]: DataAdapterType[P] extends any[] ? P : never }[keyof DataAdapterType],
+  >(
+    key: K,
+    value: DataAdapterType[K] extends (infer E)[] ? E | E[] : never,
+  ): DataAdapterType[K];
+  append<
+    K extends keyof DataAdapterType &
+      { [P in keyof DataAdapterType]: DataAdapterType[P] extends string ? P : never }[keyof DataAdapterType],
+  >(
+    key: K,
+    value: string,
+    separator?: string,
+  ): DataAdapterType[K];
+  snapshot(): DataAdapterType;
+  snapshot<K extends keyof DataAdapterType>(key?: K): DataAdapterType[K];
+  onDataChange: Signal<(detail: DataChangeSignalDetail) => void>;
+  clearOnResume?: boolean;
+}
+
+export function defineData<T extends DataSchema>(data: T): T {
+  return data;
+}
+
+/**
+ * An in-memory game-data plugin with optional localStorage backup.
+ *
+ * Not `IStorageCapability` — its API (`get`/`set`/`increment`/...) is richer
+ * than the generic save/load contract. Accessed directly via `app.data`.
+ */
+export class DataAdapter extends Plugin<Partial<IDataAdapterOptions>> implements IDataAdapter {
+  public data: DataAdapterType;
+
+  public onDataChange: Signal<(detail: DataChangeSignalDetail) => void> = new Signal();
+
+  private backupKeys: Array<keyof DataAdapterType> = [];
+  private backupAll: boolean = false;
+  private namespace: string = '';
+  private overrideWithLocalStorage: boolean = true;
+
+  constructor(id: string = 'data') {
+    super(id);
+  }
+
+  public getCoreSignals(): string[] {
+    return ['onDataChange'];
+  }
+
+  destroy() {
+    this.data = {} as DataAdapterType;
+  }
+
+  public initialize(options?: Partial<IDataAdapterOptions>): void {
+    this.namespace = options?.namespace || this.app.appName;
+    this.data = (options?.initial as DataAdapterType) || ({} as DataAdapterType);
+    this.backupKeys = options?.backupKeys || [];
+    this.backupAll = options?.backupAll || false;
+    this.overrideWithLocalStorage = options?.overrideWithLocalStorage === false ? false : true;
+
+    if (this.backupAll || this.backupKeys.length > 0) {
+      if (this.overrideWithLocalStorage) {
+        this.restoreFromLocalStorage(this.backupKeys);
+      }
+      this.backupToLocalStorage(this.backupKeys);
+    }
+  }
+
+  set<K extends keyof DataAdapterType>(key: K, data: DataAdapterType[K]): DataAdapterType;
+  set(data: DeepPartial<DataAdapterType>, merge?: boolean): DataAdapterType;
+  set<K extends keyof DataAdapterType>(
+    keyOrData: K | DeepPartial<DataAdapterType>,
+    dataOrMerge?: DataAdapterType[K] | boolean,
+  ): DataAdapterType {
+    if (typeof keyOrData === 'string' || typeof keyOrData === 'number' || typeof keyOrData === 'symbol') {
+      const key = keyOrData;
+      const data = dataOrMerge as DataAdapterType[K];
+
+      this.data[key] = data;
+      if (this.backupAll || this.backupKeys.includes(key)) {
+        this.backupToLocalStorage([key]);
+      }
+      this.onDataChange.emit({ key, value: data });
+      return this.data;
+    }
+
+    const data = keyOrData as DeepPartial<DataAdapterType>;
+    const merge = (dataOrMerge as boolean) ?? true;
+
+    if (merge) {
+      this.data = deepMerge({ ...this.data }, data);
+    } else {
+      this.data = data as DataAdapterType;
+    }
+
+    if (this.backupAll || this.backupKeys.length > 0) {
+      this.backupToLocalStorage(this.backupKeys);
+    }
+
+    this.onDataChange.emit({
+      key: Object.keys(data)?.length === 1 ? Object.keys(data)[0] : Object.keys(data),
+      value: data[Object.keys(data)[0]] as DataAdapterType[keyof DataAdapterType],
+    });
+
+    return this.data;
+  }
+
+  get(): DataAdapterType;
+  get<K extends keyof DataAdapterType>(key?: K): DataAdapterType[K] | undefined;
+  get<K extends keyof DataAdapterType>(key?: K): DataAdapterType[K] | DataAdapterType | undefined {
+    if (key === undefined) {
+      return this.data;
+    }
+    return this.data[key];
+  }
+
+  increment<
+    K extends keyof DataAdapterType &
+      { [P in keyof DataAdapterType]: DataAdapterType[P] extends number ? P : never }[keyof DataAdapterType],
+  >(key: K, amount: number = 1): DataAdapterType[K] {
+    const currentValue = this.data[key] || 0;
+    const newValue = currentValue + amount;
+    this.set({ [key]: newValue } as DeepPartial<DataAdapterType>);
+    return newValue as DataAdapterType[K];
+  }
+
+  concat<
+    K extends keyof DataAdapterType &
+      { [P in keyof DataAdapterType]: DataAdapterType[P] extends any[] ? P : never }[keyof DataAdapterType],
+  >(key: K, value: DataAdapterType[K] extends (infer E)[] ? E | E[] : never): DataAdapterType[K] {
+    const currentValue = this.data[key];
+    const newValue = [...currentValue, ...(Array.isArray(value) ? value : [value])];
+    this.set({ [key]: newValue } as DeepPartial<DataAdapterType>);
+    return newValue as DataAdapterType[K];
+  }
+
+  append<
+    K extends keyof DataAdapterType &
+      { [P in keyof DataAdapterType]: DataAdapterType[P] extends string ? P : never }[keyof DataAdapterType],
+  >(key: K, value: string, separator: string = ''): DataAdapterType[K] {
+    const currentValue = this.data[key];
+    let newValue = value;
+    if ((currentValue as string)?.length > 0) {
+      newValue = currentValue + separator + value;
+    }
+    this.set({ [key]: newValue } as DeepPartial<DataAdapterType>);
+    return newValue as DataAdapterType[K];
+  }
+
+  clear(): void;
+  clear<K extends keyof DataAdapterType>(key?: K): void {
+    if (key === undefined) {
+      this.data = {} as DataAdapterType;
+      localStorage.clear();
+      this.onDataChange.emit({ key, clear: true });
+    } else {
+      delete this.data[key];
+      localStorage.removeItem(`${this.namespace}-${key as string}`);
+      this.onDataChange.emit({ clear: true });
+    }
+  }
+
+  snapshot(): DataAdapterType;
+  snapshot<K extends keyof DataAdapterType>(key?: K): DataAdapterType[K];
+  snapshot<K extends keyof DataAdapterType>(key?: K): DataAdapterType[K] | DataAdapterType {
+    if (key === undefined) {
+      return JSON.parse(JSON.stringify(this.data));
+    }
+    return JSON.parse(JSON.stringify(this.data[key]));
+  }
+
+  private backupToLocalStorage(keys?: Array<keyof DataAdapterType>): void {
+    const dataToBackup =
+      keys && keys?.length > 0 ? Object.fromEntries(keys.map((key) => [key, this.data[key]])) : this.data;
+
+    for (const key in dataToBackup) {
+      localStorage.setItem(`${this.namespace}-${key}`, JSON.stringify(dataToBackup[key]));
+    }
+  }
+
+  private restoreFromLocalStorage(keys?: Array<keyof DataAdapterType>): void {
+    const keysToRestore = keys && keys?.length > 0 ? keys : (Object.keys(this.data) as Array<keyof DataAdapterType>);
+    keysToRestore.forEach((key) => {
+      try {
+        const loadedData = localStorage.getItem(`${this.namespace}-${String(key)}`);
+        if (loadedData !== null) {
+          try {
+            const parsedData = JSON.parse(loadedData);
+            this.data[key] = parsedData;
+          } catch (parseError) {
+            console.warn(
+              `Failed to parse data for key "${String(key)}" in namespace "${this.namespace}". Using default value.`,
+            );
+          }
+        }
+      } catch (storageError) {
+        console.error(
+          `Error accessing localStorage for key "${String(key)}" in namespace "${this.namespace}":`,
+          storageError,
+        );
+      }
+    });
+    this.onDataChange.emit({ restore: true });
+  }
+}