dyo-tools 0.3.0 → 0.4.0

package/src/core/DTManager.ts

@@ -1,465 +1,555 @@
-import DYOToolsComponent from './DTComponent';
-import DYOToolsBunch from './DTBunch';
-import DYOToolsError from './DTError';
-import {
-  DTAcceptedMetaData,
-  DTComponentOptions,
-  DTManagerFilters,
-  DTManagerItemsType,
-  DTManagerItemType,
-  DTManagerOptions,
-  DTManagerToObject,
-  DYOFinderConfiguration,
-} from '../types';
-import DYOFinder from '../libs/DYOFinder';
-import { componentManagerDefaultFinderConfiguration, managerDefaultOptions as defaultOptions } from '../constants';
-import DYOToolsElement from './DTElement';
-import DYOToolsMaster from './DTMaster';
-
-export default class DYOToolsManager<
-  IBunchItem extends DYOToolsElement<DTAcceptedMetaData> = DYOToolsElement<DTAcceptedMetaData>,
-> extends DYOToolsComponent<DTManagerOptions> {
-  /**
-   * Defining component type to "manager".
-   */
-  protected _componentType = 'manager';
-
-  /**
-   * DTBunch instances managed by the Manager.
-   *
-   * This property is an object with an entry for each bunch :
-   * * The key is the bunch _id.
-   * * The value is an object with :
-   * * * *scope* : the current affected **scope** of the bunch.
-   * * * *item* : the DTBunch instance.
-   */
-  protected _items: DTManagerItemsType<IBunchItem>;
-
-  /**
-   * Valid scopes list for bunches.
-   *
-   * Each bunch is affected to one scope, in order to facilitate filtering and grouping of bunches.
-   * A DTManager instance comes with two initial scopes : 'default' and 'virtual'.
-   */
-  protected _scopes: string[];
-
-  /**
-   * Current Library instance for the Manager.
-   *
-   * The Library is a special virtual bunch which contains all elements added in bunches.
-   * The purpose is the guarantee of id uniqueness when transferring elements between bunches.
-   * It also facilitates searching elements in all Manager bunches.
-   */
-  protected _library: DYOToolsBunch<IBunchItem>;
-
-  /**
-   * Current DYOFinder instance.
-   *
-   * This instance offers advanced methods to manipulate items, like searching.
-   */
-  protected _finder: DYOFinder;
-
-  /**
-   * Applying the parent constructor, and execute following process steps :
-   * * If **key** isn't provided and the property _domain is defined, the _key property has the _domain value.
-   * * Add *default* and *virtual* as basic _scopes value, and add **scopes**.
-   * * Create the Library instance, and add **elements** into it.
-   * * Initialize *DYOFinder* with **getFinderConfiguration** method.
-   *
-   * @param key
-   * @param elements Array of DTElement instance to add into the Manager Library. Default empty array.
-   * @param scopes Array of custom scopes for the Manager. Default empty array.
-   * @param options Specific options configuration for the instance. Default empty object.
-   */
-  constructor(key?: string, elements: IBunchItem[] = [], scopes: string[] = [], options: Partial<DTManagerOptions> = {}) {
-    super(key, { ...defaultOptions, ...options });
-    // Use default _domain as _key
-    this._key = !key ? (this.getDomain() || this._id) : key;
-
-    this._items = {};
-    this._scopes = [
-      'default',
-      'virtual',
-      ...scopes,
-    ];
-    this._library = new DYOToolsBunch('library', elements, { virtualContainer: true });
-    this._library.setContext(this);
-
-    this._finder = new DYOFinder(this, this.getFinderConfiguration());
-  }
-
-  /**
-   * Returns DYOFinder configuration for standard DTManager instance.
-   *
-   * This method can be overridden to extend the configuration.
-   *
-   * @returns DYOFinderConfiguration standard configuration.
-   */
-  getFinderConfiguration(): DYOFinderConfiguration {
-    return componentManagerDefaultFinderConfiguration;
-  }
-
-  /**
-   * Getter for _library property.
-   */
-  getLibrary(): DYOToolsBunch<IBunchItem> {
-    return this._library;
-  }
-
-  /**
-   * Getter for _scopes property.
-   */
-  getScopes(): string[] {
-    return this._scopes;
-  }
-
-  /**
-   * Define if a scope name is a valid scope into the Manager.
-   *
-   * @param scope scope name.
-   * @returns boolean if the scope is valid or not.
-   */
-  isValidScope(scope: string): boolean {
-    return this._scopes.includes(scope);
-  }
-
-  /**
-   * Add a DTBunch **item** into _items Manager property.
-   *
-   * The adding process has the following specifications :
-   * * If the added item has the same _id than existing item, an error occurred (depending on **errors** option).
-   * * The bunch item is automatically added to a scope depending on its virtual context :
-   * * * *default* if the bunch option **virtualContainer** is false.
-   * * * *virtual* if the bunch option **virtualContainer** is true.
-   * * An optional parameter **targetScope** can be passed to force the scope affectation.
-   * An error occurred if the affection doesn't conform to the following restrictions :
-   * * * Virtual context bunch must be affected to the 'virtual' scope.
-   * * * Not virtual context bunch must be affected to the 'default' scope, or any scope other than the 'virtual' one.
-   * * All elements of the added bunch item are added to the Manager Library, only if the element doesn't already exist
-   * into the Library.
-   * * The Manager instance becomes the new context of the added item.
-   * * The added item format follows the type DTManagerItemsType.
-   * @see DTManagerItemsType
-   *
-   * @param item A DTBunch instance to add into the Manager.
-   * @param targetScope Optional scope for affectation.
-   */
-  add(item: DYOToolsBunch<IBunchItem>, targetScope?: string): void {
-    // Id conflict
-    if (Object.keys(this._items).includes(item.getId())) {
-      this.triggerError(new DYOToolsError(
-        'id_conflict',
-        'Bunch with same id already exists in the manager',
-        this,
-        item,
-      ));
-      return;
-    }
-
-    // Define scope validity
-    const { virtualContainer } = item.getOptions();
-    let scope;
-    if (!targetScope) {
-      scope = virtualContainer ? 'virtual' : 'default';
-    } else {
-      const { code: errorCode, message: errorMessage } = this.getErrorDataForScope(targetScope, virtualContainer);
-
-      if (errorCode && errorMessage) {
-        this.triggerError(new DYOToolsError(errorCode, errorMessage, this, item));
-        return;
-      }
-      scope = targetScope;
-    }
-
-    // Update Library with non-existing new Elements
-    if (item.getAll().length) {
-      item.getAll().forEach((element: IBunchItem) => {
-        if (!this._library.get(element.getId())) {
-          this._library.add(element);
-        }
-      });
-    }
-
-    // Update context
-    // Bunch
-    item.setContext<DYOToolsManager<IBunchItem>>(this);
-    const oldContext = item.getContext();
-    if (oldContext && oldContext.getComponentType() === 'manager') {
-      (oldContext as DYOToolsManager<IBunchItem>).remove(item.getId());
-    }
-
-    // Elements children
-    item.getAll().forEach((element) => {
-      element.setContext<DYOToolsManager<IBunchItem>>(this);
-    });
-
-    // Add the new item
-    this._items[item.getId()] = {
-      scope,
-      item,
-    };
-  }
-
-  /**
-   * Add each bunch of an array **items** into _items Manager property.
-   *
-   * @see [add](#add) method for adding specifications.
-   * @param items An array of DTBunch instances to add into the Manager.
-   * @param targetScope Optional scope for affectation (all added items are affected).
-   */
-  addMany(items: DYOToolsBunch<IBunchItem>[], targetScope?: string): void {
-    const previousItems = { ...this._items };
-    const { errors }: DTComponentOptions = this._options;
-
-    try {
-      items.forEach((item: DYOToolsBunch<IBunchItem>) => {
-        this.add(item, targetScope);
-      });
-    } catch (err: unknown) {
-      this._items = previousItems;
-      if (!errors) {
-        throw err;
-      }
-    }
-  }
-
-  /**
-   * Move a bunch item to a new scope.
-   *
-   * Note : an error occurred (depending on **errors** option) if the bunch id doesn't exist into the Manager.
-   *
-   * @see [add](#add) method for restrictions into the scope affectation.
-   * @param bunchId _id property of the bunch to move.
-   * @param targetScope new scope of the bunch.
-   */
-  moveToScope(bunchId: string, targetScope: string): void {
-    if (!Object.keys(this._items).includes(bunchId)) {
-      this.triggerError(new DYOToolsError(
-        'invalid_id',
-        'Bunch id provided doesn\'t exist in the manager',
-        this,
-      ));
-      return;
-    }
-
-    const bunch = this._items[bunchId].item;
-
-    const { virtualContainer } = bunch.getOptions();
-    const { code: errorCode, message: errorMessage } = this.getErrorDataForScope(targetScope, virtualContainer);
-    if (errorCode && errorMessage) {
-      this.triggerError(new DYOToolsError(errorCode, errorMessage, this, bunch));
-      return;
-    }
-
-    this._items[bunchId].scope = targetScope;
-  }
-
-  /**
-   * Return one DTBunch instance included in the _items property by id.
-   *
-   * @param id bunch id to return.
-   * @returns DYOToolsBunch instance that corresponds to the id provided, or undefined if not found.
-   */
-  get(id: string): DYOToolsBunch<IBunchItem> | undefined {
-    return this._items[id]?.item ?? undefined;
-  }
-
-  /**
-   * Return all DTBunch instance managed into the Manager.
-   *
-   * @param scope Optional parameter **scope** to return only bunches which are affected to a specific scope.
-   * @returns DYOToolsBunch array.
-   */
-  getAll(scope?: string): DYOToolsBunch<IBunchItem>[] {
-    const finalItems = [];
-    Object.values(this._items).forEach((item: DTManagerItemType<IBunchItem>) => {
-      if (!scope || item.scope === scope) {
-        finalItems.push(item.item);
-      }
-    });
-
-    return finalItems;
-  }
-
-  /**
-   * Return the current affected scope of a bunch depending on its id.
-   *
-   * @param id bunch id to return.
-   * @returns Current scope affected to the bunch, or undefined if the bunch doesn't exist.
-   */
-  getScope(id: string): string | undefined {
-    return this._items[id] && this._items[id].scope;
-  }
-
-  /**
-   * Returns Master component from context, or undefined.
-   */
-  getMaster(): DYOToolsMaster | undefined {
-    return this.getContext<DYOToolsMaster>('master');
-  }
-
-  /**
-   * Remove one bunch into the _items property of the Manager, depending on its id.
-   *
-   * If option **libraryDeletion** is *true*, the method performs also a deletion of removed bunch elements
-   * in the Manager Library.
-   *
-   * @param id bunch id to remove.
-   */
-  remove(id: string): void {
-    this.removeMany([id]);
-  }
-
-  /**
-   * Remove many bunches into the _items property of the Manager, depending on their ids.
-   *
-   * If option **libraryDeletion** is *true*, the method performs also a deletion of removed bunch elements
-   * in the Manager Library.
-   *
-   * @param ids Array of bunch ids to remove.
-   * @param options Optional Manager option configuration object to apply only for this method execution. Options are not
-   * saved in current _options property. Available Options are : **libraryDeletion** and **errors**.
-   */
-  removeMany(ids: string[], options: Partial<DTManagerOptions> = {}): void {
-    const { libraryDeletion } = { ...this._options, ...options };
-
-    ids.forEach((id: string) => {
-      if (this._items[id]) {
-        this._items[id].item.getAll().forEach((item: IBunchItem) => {
-          if (libraryDeletion) {
-            this._library.remove(item.getId());
-          }
-          item.removeContext();
-        });
-
-        this._items[id].item.removeContext();
-        delete this._items[id];
-      }
-    });
-  }
-
-  /**
-   * Remove all bunches into the _items property of the Manager.
-   *
-   * If option **libraryDeletion** is *true*, the method performs also a deletion of removed bunch elements
-   * in the Manager Library.
-   */
-  removeAll(): void {
-    this.removeMany(Object.keys(this._items));
-  }
-
-  /**
-   * Return an array of DTBunch from _items property filtered with a **filters** argument.
-   *
-   * This method use the DYOFinder instance **execute** method.
-   *
-   * Search filters can be applied on following bunch properties :
-   * * **id** : property _id. Basic operators only.
-   * * **key** : property _key. Basic operators only.
-   * * **scope** : affected scope name. Basic operators only.
-   * * **owner** : property _id of current _owner instance. Basic operators only.
-   * * **meta** : each meta Key of _meta property. Extended operators can be used.
-   *
-   * Examples of **filters** argument :
-   * * { key: { $eq: "key_1" } } : Return all DTBunch instances into _items with *key_1* as _key property.
-   * * { scope: { $in: ["default", "scope_1"] } } : Return all DTBunch instances into _items affected to scopes
-   * "default" or "scope_1".
-   * * { key: { $ne: "key_1" }, meta: { score: { $gte: 50, $lte: 100 } } } : Return all DTBunch instance into _items
-   * with _key property different from *key_1*, and meta key *score* value from _meta property between 50 and 100.
-   *
-   * @param filters Filters Object. The format is :
-   * { [property_1] : { [operator_1] : filter_value, [operator_2] : filter_value_2, ... }, [property_2] : { ... }, ... }
-   *
-   * For **meta**, you have to pass the meta key before the operator :
-   * { meta: { [meta_key1] : { [operator_1] : filter_value_1, ... }, [meta_key2] : { ... }, ...  }, ... }
-   * @returns Array of DTBunch instance corresponding to the filters. Empty if no filter or invalid ones are passed.
-   * @see DYOFinder
-   */
-  find(filters: Partial<DTManagerFilters>): DYOToolsBunch<IBunchItem>[] {
-    return this._finder.execute<DYOToolsBunch<IBunchItem>>(filters);
-  }
-
-  /**
-   * Remove all items into the Manager Library, and add items from all bunches instance managed by the Manager.
-   *
-   * This method is useful to guarantee that the Library contains all bunches items, especially after many complex
-   * operations.
-   */
-  reloadLibrary(): void {
-    this._library.removeAll();
-
-    Object.values(this._items).forEach((item: DTManagerItemType<IBunchItem>) => {
-      item.item.getAll().forEach((element: IBunchItem) => {
-        if (!this._library.get(element.getId())) {
-          this._library.add(element);
-        }
-      });
-    });
-  }
-
-  /**
-   * Return JSON Object representation of the Manager instance.
-   *
-   * JSON Object returned has the following structure :
-   * * **id** : _id property of the Manager.
-   * * **key** : _key property of the Manager.
-   * * **type** : _componentType property of the Manager.
-   * * **items** : Array of JSON Object representation for each DTBunch instance in _items property of the Manager.
-   *
-   * @returns JSON Object representation of the Manager.
-   */
-  toObject(): DTManagerToObject {
-    const objectManager: DTManagerToObject = {
-      id: this._id,
-      key: this._key,
-      type: this._componentType,
-      items: [],
-    };
-
-    Object.keys(this._items).forEach((bunchId: string) => {
-      objectManager.items.push({
-        scope: this._items[bunchId].scope,
-        ...this._items[bunchId].item.toObject(),
-      });
-    });
-
-    return objectManager;
-  }
-
-  /**
-   * Return String representation of the Manager instance.
-   *
-   * @returns String representation of the Manager.
-   */
-  toString(): string {
-    const libraryLabel = `Library: ${this._library.getAll().length}`;
-    const domainLabel = this._domain ? ` ${this._domain}` : '';
-
-    return `Component${domainLabel} ${this._key} - Type: Manager - ${libraryLabel} - Items: ${Object.keys(this._items).length}`;
-  }
-
-  /**
-   * Get error data for scope affectation. Used in method which performs scope affectation.
-   *
-   * @param targetScope scope name to check for affectation.
-   * @param virtualContainer boolean if the bunch to affect has **virtualContainer** option enabled or not. Default *false*.
-   * @returns An Object with error code and message.
-   */
-  private getErrorDataForScope(targetScope: string, virtualContainer = false): { code: string, message: string } {
-    const response = { code: '', message: '' };
-    if (!this.isValidScope(targetScope)) {
-      response.code = 'invalid_scope';
-      response.message = "Scope provided doesn't exist in the manager";
-    }
-    if (virtualContainer && targetScope !== 'virtual') {
-      response.code = 'forbidden_scope';
-      response.message = 'Scope provided cannot be associated to a virtual bunch';
-    }
-    if (!virtualContainer && targetScope === 'virtual') {
-      response.code = 'forbidden_virtual_scope';
-      response.message = 'Virtual Scope provided cannot be associated to a physical bunch';
-    }
-
-    return response;
-  }
-}
+import DTComponent from './DTComponent';
+import DTBunch from './DTBunch';
+import DTError from './DTError';
+import {
+  DIXObject,
+  DTAcceptedMetaData,
+  DTComponentOptions,
+  DTManagerFilters,
+  DTManagerItemsType,
+  DTManagerItemType,
+  DTManagerOptions,
+  DTManagerToObject,
+  DYOFinderConfiguration,
+} from '../types';
+import DYOFinder from '../libs/DYOFinder';
+import { componentManagerDefaultFinderConfiguration, managerDefaultOptions as defaultOptions } from '../constants';
+import DTElement from './DTElement';
+import DTMaster from './DTMaster';
+import DTDIXModule from '../libs/dix/DIXModule.module';
+
+export default class DTManager<
+  IBunchItem extends DTElement<DTAcceptedMetaData> = DTElement<DTAcceptedMetaData>,
+> extends DTComponent<DTManagerOptions> {
+  /**
+   * Defining component type to "manager".
+   */
+  protected _componentType = 'manager';
+
+  /**
+   * DTBunch instances managed by the Manager.
+   *
+   * This property is an object with an entry for each bunch :
+   * * The key is the bunch _id.
+   * * The value is an object with :
+   * * * *scope* : the current affected **scope** of the bunch.
+   * * * *item* : the DTBunch instance.
+   */
+  protected _items: DTManagerItemsType<IBunchItem>;
+
+  /**
+   * Valid scopes list for bunches.
+   *
+   * Each bunch is affected to one scope, in order to facilitate filtering and grouping of bunches.
+   * A DTManager instance comes with two initial scopes : 'default' and 'virtual'.
+   */
+  protected _scopes: string[];
+
+  /**
+   * Current Library instance for the Manager.
+   *
+   * The Library is a special virtual bunch which contains all elements added in bunches.
+   * The purpose is the guarantee of id uniqueness when transferring elements between bunches.
+   * It also facilitates searching elements in all Manager bunches.
+   */
+  protected _library: DTBunch<IBunchItem>;
+
+  /**
+   * Current DYOFinder instance.
+   *
+   * This instance offers advanced methods to manipulate items, like searching.
+   */
+  protected _finder: DYOFinder;
+
+  /**
+   * Applying the parent constructor, and execute following process steps :
+   * * If **key** isn't provided and the property _domain is defined, the _key property has the _domain value.
+   * * Add *default* and *virtual* as basic _scopes value, and add **scopes**.
+   * * Create the Library instance, and add **elements** into it.
+   * * Initialize *DYOFinder* with **getFinderConfiguration** method.
+   *
+   * @param key
+   * @param elements Array of DTElement instance to add into the Manager Library. Default empty array.
+   * @param scopes Array of custom scopes for the Manager. Default empty array.
+   * @param options Specific options configuration for the instance. Default empty object.
+   */
+  constructor(key?: string, elements: IBunchItem[] = [], scopes: string[] = [], options: Partial<DTManagerOptions> = {}) {
+    super(key, { ...defaultOptions, ...options });
+
+    this._items = {};
+    this._scopes = [
+      'default',
+      'virtual',
+      ...scopes,
+    ];
+    this._library = new DTBunch('library', elements, { virtualContainer: true });
+    this._library.setContext(this);
+
+    this._finder = new DYOFinder(this, this.getFinderConfiguration());
+  }
+
+  /**
+   * Returns DYOFinder configuration for standard DTManager instance.
+   *
+   * This method can be overridden to extend the configuration.
+   *
+   * @returns DYOFinderConfiguration standard configuration.
+   */
+  getFinderConfiguration(): DYOFinderConfiguration {
+    return componentManagerDefaultFinderConfiguration;
+  }
+
+  /**
+   * Getter for _library property.
+   */
+  getLibrary(): DTBunch<IBunchItem> {
+    return this._library;
+  }
+
+  /**
+   * Getter for _scopes property.
+   */
+  getScopes(): string[] {
+    return this._scopes;
+  }
+
+  /**
+   * Define if a scope name is a valid scope into the Manager.
+   *
+   * @param scope scope name.
+   * @returns boolean if the scope is valid or not.
+   */
+  isValidScope(scope: string): boolean {
+    return this._scopes.includes(scope);
+  }
+
+  /**
+   * Add a DTBunch **item** into _items Manager property.
+   *
+   * The adding process has the following specifications :
+   * * If the added item has the same _id than existing item, an error occurred (depending on **errors** option).
+   * * The bunch item is automatically added to a scope depending on its virtual context :
+   * * * *default* if the bunch option **virtualContainer** is false.
+   * * * *virtual* if the bunch option **virtualContainer** is true.
+   * * An optional parameter **targetScope** can be passed to force the scope affectation.
+   * An error occurred if the affection doesn't conform to the following restrictions :
+   * * * Virtual context bunch must be affected to the 'virtual' scope.
+   * * * Not virtual context bunch must be affected to the 'default' scope, or any scope other than the 'virtual' one.
+   * * All elements of the added bunch item are added to the Manager Library, only if the element doesn't already exist
+   * into the Library.
+   * * The Manager instance becomes the new context of the added item.
+   * * The added item format follows the type DTManagerItemsType.
+   * @see DTManagerItemsType
+   *
+   * @param item A DTBunch instance to add into the Manager.
+   * @param targetScope Optional scope for affectation.
+   */
+  add(item: DTBunch<IBunchItem>, targetScope?: string): void {
+    // Id conflict
+    if (Object.keys(this._items).includes(item.getId())) {
+      this.triggerError(new DTError(
+        'id_conflict',
+        'Bunch with same id already exists in the manager',
+        this,
+        item,
+      ));
+      return;
+    }
+
+    // Define scope validity
+    const { virtualContainer } = item.getOptions();
+    let scope;
+    if (!targetScope) {
+      scope = virtualContainer ? 'virtual' : 'default';
+    } else {
+      const { code: errorCode, message: errorMessage } = this.getErrorDataForScope(targetScope, virtualContainer);
+
+      if (errorCode && errorMessage) {
+        this.triggerError(new DTError(errorCode, errorMessage, this, item));
+        return;
+      }
+      scope = targetScope;
+    }
+
+    // Update Library with non-existing new Elements
+    if (item.getAll().length) {
+      item.getAll().forEach((element: IBunchItem) => {
+        if (!this._library.get(element.getId())) {
+          this._library.add(element);
+        }
+      });
+    }
+
+    // Update context
+    // Bunch
+    const oldContext = item.getContext();
+    if (oldContext && oldContext.getComponentType() === 'manager') {
+      (oldContext as DTManager<IBunchItem>).remove(item.getId());
+    }
+    item.setContext<DTManager<IBunchItem>>(this);
+
+    // Elements children
+    item.getAll().forEach((element) => {
+      element.setContext<DTManager<IBunchItem>>(this);
+    });
+
+    // Add the new item
+    this._items[item.getId()] = {
+      scope,
+      item,
+    };
+  }
+
+  /**
+   * Add each bunch of an array **items** into _items Manager property.
+   *
+   * @see [add](#add) method for adding specifications.
+   * @param items An array of DTBunch instances to add into the Manager.
+   * @param targetScope Optional scope for affectation (all added items are affected).
+   */
+  addMany(items: DTBunch<IBunchItem>[], targetScope?: string): void {
+    const previousItems = { ...this._items };
+    const { errors }: DTComponentOptions = this._options;
+
+    try {
+      items.forEach((item: DTBunch<IBunchItem>) => {
+        this.add(item, targetScope);
+      });
+    } catch (err: unknown) {
+      this._items = previousItems;
+      if (!errors) {
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Move a bunch item to a new scope.
+   *
+   * Note : an error occurred (depending on **errors** option) if the bunch id doesn't exist into the Manager.
+   *
+   * @see [add](#add) method for restrictions into the scope affectation.
+   * @param bunchId _id property of the bunch to move.
+   * @param targetScope new scope of the bunch.
+   */
+  moveToScope(bunchId: string, targetScope: string): void {
+    if (!Object.keys(this._items).includes(bunchId)) {
+      this.triggerError(new DTError(
+        'invalid_id',
+        'Bunch id provided doesn\'t exist in the manager',
+        this,
+      ));
+      return;
+    }
+
+    const bunch = this._items[bunchId].item;
+
+    const { virtualContainer } = bunch.getOptions();
+    const { code: errorCode, message: errorMessage } = this.getErrorDataForScope(targetScope, virtualContainer);
+    if (errorCode && errorMessage) {
+      this.triggerError(new DTError(errorCode, errorMessage, this, bunch));
+      return;
+    }
+
+    this._items[bunchId].scope = targetScope;
+  }
+
+  /**
+   * Return one DTBunch instance included in the _items property by id.
+   *
+   * @param id bunch id to return.
+   * @returns DYOToolsBunch instance that corresponds to the id provided, or undefined if not found.
+   */
+  get(id: string): DTBunch<IBunchItem> | undefined {
+    return this._items[id]?.item ?? undefined;
+  }
+
+  /**
+   * Return all DTBunch instance managed into the Manager.
+   *
+   * @param scope Optional parameter **scope** to return only bunches which are affected to a specific scope.
+   * @returns DYOToolsBunch array.
+   */
+  getAll(scope?: string): DTBunch<IBunchItem>[] {
+    const finalItems = [];
+    Object.values(this._items).forEach((item: DTManagerItemType<IBunchItem>) => {
+      if (!scope || item.scope === scope) {
+        finalItems.push(item.item);
+      }
+    });
+
+    return finalItems;
+  }
+
+  /**
+   * Return the current affected scope of a bunch depending on its id.
+   *
+   * @param id bunch id to return.
+   * @returns Current scope affected to the bunch, or undefined if the bunch doesn't exist.
+   */
+  getScope(id: string): string | undefined {
+    return this._items[id] && this._items[id].scope;
+  }
+
+  /**
+   * Returns Master component from context, or undefined.
+   */
+  getMaster(): DTMaster | undefined {
+    return this.getContext<DTMaster>('master');
+  }
+
+  /**
+   * Remove one bunch into the _items property of the Manager, depending on its id.
+   *
+   * If option **libraryDeletion** is *true*, the method performs also a deletion of removed bunch elements
+   * in the Manager Library.
+   *
+   * @param id bunch id to remove.
+   */
+  remove(id: string): void {
+    this.removeMany([id]);
+  }
+
+  /**
+   * Remove many bunches into the _items property of the Manager, depending on their ids.
+   *
+   * If option **libraryDeletion** is *true*, the method performs also a deletion of removed bunch elements
+   * in the Manager Library.
+   *
+   * @param ids Array of bunch ids to remove.
+   * @param options Optional Manager option configuration object to apply only for this method execution. Options are not
+   * saved in current _options property. Available Options are : **libraryDeletion** and **errors**.
+   */
+  removeMany(ids: string[], options: Partial<DTManagerOptions> = {}): void {
+    const { libraryDeletion } = { ...this._options, ...options };
+
+    ids.forEach((id: string) => {
+      if (this._items[id]) {
+        this._items[id].item.getAll().forEach((item: IBunchItem) => {
+          if (libraryDeletion) {
+            this._library.remove(item.getId());
+          }
+          item.removeContainer();
+        });
+
+        this._items[id].item.removeContext();
+        delete this._items[id];
+      }
+    });
+  }
+
+  /**
+   * Remove all bunches into the _items property of the Manager.
+   *
+   * If option **libraryDeletion** is *true*, the method performs also a deletion of removed bunch elements
+   * in the Manager Library.
+   */
+  removeAll(): void {
+    this.removeMany(Object.keys(this._items));
+  }
+
+  /**
+   * Return an array of DTBunch from _items property filtered with a **filters** argument.
+   *
+   * This method use the DYOFinder instance **execute** method.
+   *
+   * Search filters can be applied on following bunch properties :
+   * * **id** : property _id. Basic operators only.
+   * * **key** : property _key. Basic operators only.
+   * * **scope** : affected scope name. Basic operators only.
+   * * **owner** : property _id of current _owner instance. Basic operators only.
+   * * **meta** : each meta Key of _meta property. Extended operators can be used.
+   *
+   * Examples of **filters** argument :
+   * * { key: { $eq: "key_1" } } : Return all DTBunch instances into _items with *key_1* as _key property.
+   * * { scope: { $in: ["default", "scope_1"] } } : Return all DTBunch instances into _items affected to scopes
+   * "default" or "scope_1".
+   * * { key: { $ne: "key_1" }, meta: { score: { $gte: 50, $lte: 100 } } } : Return all DTBunch instance into _items
+   * with _key property different from *key_1*, and meta key *score* value from _meta property between 50 and 100.
+   *
+   * @param filters Filters Object. The format is :
+   * { [property_1] : { [operator_1] : filter_value, [operator_2] : filter_value_2, ... }, [property_2] : { ... }, ... }
+   *
+   * For **meta**, you have to pass the meta key before the operator :
+   * { meta: { [meta_key1] : { [operator_1] : filter_value_1, ... }, [meta_key2] : { ... }, ...  }, ... }
+   * @returns Array of DTBunch instance corresponding to the filters. Empty if no filter or invalid ones are passed.
+   * @see DYOFinder
+   */
+  find(filters: Partial<DTManagerFilters>): DTBunch<IBunchItem>[] {
+    return this._finder.execute<DTBunch<IBunchItem>>(filters);
+  }
+
+  /**
+   * Remove all items into the Manager Library, and add items from all bunches instance managed by the Manager.
+   *
+   * This method is useful to guarantee that the Library contains all bunches items, especially after many complex
+   * operations.
+   */
+  reloadLibrary(): void {
+    this._library.removeAll();
+
+    Object.values(this._items).forEach((item: DTManagerItemType<IBunchItem>) => {
+      item.item.getAll().forEach((element: IBunchItem) => {
+        if (!this._library.get(element.getId())) {
+          this._library.add(element);
+        }
+      });
+    });
+  }
+
+  /**
+   * Return JSON Object representation of the Manager instance.
+   *
+   * JSON Object returned has the following structure :
+   * * **id** : _id property of the Manager.
+   * * **key** : _key property of the Manager.
+   * * **type** : _componentType property of the Manager.
+   * * **items** : Array of JSON Object representation for each DTBunch instance in _items property of the Manager.
+   *
+   * @returns JSON Object representation of the Manager.
+   */
+  toObject(): DTManagerToObject {
+    const objectManager: DTManagerToObject = {
+      id: this._id,
+      key: this._key,
+      type: this._componentType,
+      items: [],
+    };
+
+    Object.keys(this._items).forEach((bunchId: string) => {
+      objectManager.items.push({
+        scope: this._items[bunchId].scope,
+        ...this._items[bunchId].item.toObject(),
+      });
+    });
+
+    return objectManager;
+  }
+
+  /**
+   * Return String representation of the Manager instance.
+   *
+   * @returns String representation of the Manager.
+   */
+  toString(): string {
+    const libraryLabel = `Library: ${this._library.getAll().length}`;
+    const domainLabel = this._domain ? ` ${this._domain}` : '';
+
+    return `Component${domainLabel} ${this._key} - Type: Manager - ${libraryLabel} - Items: ${Object.keys(this._items).length}`;
+  }
+
+  /**
+   * Get error data for scope affectation. Used in method which performs scope affectation.
+   *
+   * @param targetScope scope name to check for affectation.
+   * @param virtualContainer boolean if the bunch to affect has **virtualContainer** option enabled or not. Default *false*.
+   * @returns An Object with error code and message.
+   */
+  private getErrorDataForScope(targetScope: string, virtualContainer = false): { code: string, message: string } {
+    const response = { code: '', message: '' };
+    if (!this.isValidScope(targetScope)) {
+      response.code = 'invalid_scope';
+      response.message = "Scope provided doesn't exist in the manager";
+    }
+    if (virtualContainer && targetScope !== 'virtual') {
+      response.code = 'forbidden_scope';
+      response.message = 'Scope provided cannot be associated to a virtual bunch';
+    }
+    if (!virtualContainer && targetScope === 'virtual') {
+      response.code = 'forbidden_virtual_scope';
+      response.message = 'Virtual Scope provided cannot be associated to a physical bunch';
+    }
+
+    return response;
+  }
+
+  /**
+   * Return DIX Object representation of the DTManager instance.
+   *
+   * @returns DIX Object representation of the DTManager.
+   */
+  toDIXObject(): Record<string, DIXObject> {
+    const parentDixObject = super.toDIXObject();
+    const dixObject: DIXObject = {
+      ...parentDixObject[this._id],
+      items: Object.keys(this._items),
+      library: this._library.getId(),
+    };
+
+    // Library Dix Object
+    // Empty string for options because not relevant
+    const libraryDix: DIXObject = {
+      ...this._library.toDIXObject()[this._library.getId()],
+      options: '',
+    };
+
+    // Add Scopes
+    // Only non default scopes
+    const scopesForDix = this._scopes.filter((sc) => !['default', 'virtual'].includes(sc));
+    if (scopesForDix.length > 0) {
+      dixObject.scopes = scopesForDix;
+    }
+
+    const finalDix = {
+      [this._id]: dixObject,
+      ...this._library.toDIXObject(),
+      [this._library.getId()]: libraryDix,
+    };
+
+    Object.values(this._items).forEach((item) => {
+      const itemDix = item.item.toDIXObject();
+      itemDix[item.item.getId()].scope = item.scope;
+
+      Object.assign(finalDix, {
+        ...itemDix,
+      });
+    });
+
+    return finalDix;
+  }
+
+  /**
+   * Update the DTManager instance with a DIX Object.
+   *
+   * @param dix DIX Object to use for updating.
+   */
+  updateFromDix(dix: Record<string, DIXObject>): void {
+    const dixObject = dix[this._id];
+    const dixModule = this.getMaster()?.getModule('dix') as DTDIXModule;
+
+    if (dixObject && dixModule?.isEnabled()) {
+      // Synchronize Library
+      if (dixObject.library) {
+        this._library = new DTBunch('library', [], { virtualContainer: true, syncId: dixObject.library });
+        this._library.setContext(this);
+        this._library.updateFromDix(dix);
+      }
+
+      // Synchronize Bunches
+      if (dixObject.items) {
+        // Remove items
+        this.getAll().forEach((it) => {
+          if (!dixObject.items.includes(it.getId())) {
+            this.remove(it.getId());
+          }
+        });
+
+        // Add and update existing items
+        dixObject.items.forEach((itemId) => {
+          if (this.get(itemId)) {
+            this.get(itemId).updateFromDix(dix);
+          } else {
+            const newBunch = dixModule.syncNewItem(itemId, dix) as DTBunch<IBunchItem>;
+            this.add(newBunch);
+            newBunch.updateFromDix(dix);
+          }
+          // Move to scope
+          const bunchDixObject = dix[itemId];
+          if (bunchDixObject) {
+            this.moveToScope(itemId, bunchDixObject.scope);
+          }
+        });
+      }
+    }
+  }
+}