dyo-tools 0.3.2 → 0.4.0

package/src/libs/DYOFinder.ts

@@ -1,175 +1,175 @@
-import {
-  DYOFinderComponentType,
-  DYOFinderConfiguration,
-  DYOFinderFilterOperator,
-  DYOFinderFilters,
-  FilterOperatorType,
-  StandardPrimitiveType,
-  StandardPrimitiveTypeWithArray,
-} from '../types';
-
-export default class DYOFinder {
-  /**
-   * Current DTComponent associated to the Finder.
-   */
-  protected _component: DYOFinderComponentType;
-
-  /**
-   * Current DYOFinder configuration applied.
-   */
-  protected _configuration: DYOFinderConfiguration;
-
-  /**
-   * Set _component and _configuration properties.
-   *
-   * @param component
-   * @param configuration
-   */
-  constructor(component: DYOFinderComponentType, configuration: DYOFinderConfiguration) {
-    this._component = component;
-    this._configuration = configuration;
-  }
-
-  /**
-   * Getter for _component property.
-   */
-  getComponent(): DYOFinderComponentType {
-    return this._component;
-  }
-
-  /**
-   * Return an array of DTComponent from *_component* **_items** property filtered with a **filters** argument.
-   *
-   * Search filters can be applied on properties depending on the current _configuration provided.
-   *
-   * For each search filter provided, an object of specific operators is applied :
-   * * **BASIC OPERATORS**
-   * * **$eq** : The property must be strict equal to the filter value.
-   * * **$in** : The property must be included into the filter array.
-   * * **$nin** : The property must not be included into the filter array.
-   * * **$ne** : The property must be different to the filter value.
-   * * **EXTENDED OPERATORS** (meta only)
-   * * **$lte** : Number property only. The property must be lower or equal than the filter value.
-   * * **$gte** : Number property only. The property must be higher or equal than the filter array.
-   * * **$contains** : Array property only. The property must contain the filter value.
-   * * **$ncontains** : Array property only. The property must not contain the filter value.
-   *
-   * If many operators and / or many properties are passed into the **filters** argument, the logic operator applied is
-   * **AND**.
-   *
-   * @param filters Filters Object. The format is :
-   * { [property_1] : { [operator_1] : filter_value, [operator_2] : filter_value_2, ... }, [property_2] : { ... }, ... }
-   *
-   * For **objectSearch** properties, you have to pass the object key before the operator :
-   * { [property_1]: { [object_key1] : { [operator_1] : filter_value_1, ... }, [object_key2] : { ... }, ...  }, ... }
-   * @returns Array of DTComponent instance corresponding to the filters. Empty if no filter or invalid ones are passed.
-   */
-  execute<ITEM>(filters: DYOFinderFilters): ITEM[] {
-    const items = this._component.getAll();
-    const filteredItems = [];
-
-    for (const item of items) {
-      let validItem = !!(Object.keys(filters).length);
-
-      for (const [propKey, configProp] of Object.entries(this._configuration)) {
-        if (filters[propKey]) {
-          if (configProp.objectSearch) {
-            const objectValue = configProp.getValue(item, this.getComponent());
-            if (objectValue) {
-              for (const [filterK, filterV] of Object.entries(filters[propKey])) {
-                const metaValue = Object.prototype.hasOwnProperty.call(objectValue, filterK) ? objectValue[filterK] : undefined;
-                if (!this.checkAllValidFiltersForProp(metaValue, filterV, configProp.operators)) {
-                  validItem = false;
-                  break;
-                }
-              }
-            } else {
-              validItem = false;
-            }
-          } else if (!this.checkAllValidFiltersForProp(
-            (configProp.getValue(item, this.getComponent()) as StandardPrimitiveType),
-            filters[propKey],
-            configProp.operators,
-          )) {
-            validItem = false;
-          }
-        }
-      }
-
-      if (validItem) {
-        filteredItems.push(item);
-      }
-    }
-
-    return filteredItems;
-  }
-
-  private checkAllValidFiltersForProp = (
-    itemProp: StandardPrimitiveTypeWithArray,
-    operators: Partial<DYOFinderFilterOperator>,
-    validOperators: FilterOperatorType[],
-  ) => {
-    if (Object.keys(operators).length) {
-      for (const operator of Object.keys(operators)) {
-        if (!validOperators.includes(operator as FilterOperatorType)
-          || !this.validFiltersForItem(itemProp, operators[operator], operator as FilterOperatorType)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    return false;
-  };
-
-  private validFiltersForItem(
-    itemProp: StandardPrimitiveTypeWithArray,
-    filter: StandardPrimitiveTypeWithArray,
-    operator: FilterOperatorType,
-  ): boolean {
-    // $eq Filter
-    if (operator === FilterOperatorType.EQ) {
-      return itemProp === filter;
-    }
-    // $in Filter
-    if (operator === FilterOperatorType.IN) {
-      return filter ? (filter as Array<StandardPrimitiveType>).includes(itemProp as StandardPrimitiveType) : false;
-    }
-    // $nin Filter
-    if (operator === FilterOperatorType.NIN) {
-      return filter ? !(filter as Array<StandardPrimitiveType>).includes(itemProp as StandardPrimitiveType) : false;
-    }
-    // $ne Filter
-    /* c8 ignore next */
-    if (operator === FilterOperatorType.NE) {
-      return itemProp !== filter;
-    }
-    // $lte Filter
-    if (operator === FilterOperatorType.LTE) {
-      if (typeof itemProp === 'number' && typeof filter === 'number') {
-        return itemProp <= filter;
-      }
-      return false;
-    }
-    // $gte Filter
-    if (operator === FilterOperatorType.GTE) {
-      if (typeof itemProp === 'number' && typeof filter === 'number') {
-        return itemProp >= filter;
-      }
-      return false;
-    }
-    // $contains Filter
-    if (operator === FilterOperatorType.CONTAINS) {
-      return (itemProp && Array.isArray(itemProp))
-        ? (itemProp as Array<StandardPrimitiveType>).includes(filter as StandardPrimitiveType)
-        : false;
-    }
-    // $ncontains Filter
-    if (operator === FilterOperatorType.NCONTAINS) {
-      return (itemProp && Array.isArray(itemProp))
-        ? !(itemProp as Array<StandardPrimitiveType>).includes(filter as StandardPrimitiveType)
-        : false;
-    }
-
-    return false;
-  }
-}
+import {
+  DYOFinderComponentType,
+  DYOFinderConfiguration,
+  DYOFinderFilterOperator,
+  DYOFinderFilters,
+  FilterOperatorType,
+  StandardPrimitiveType,
+  StandardPrimitiveTypeWithArray,
+} from '../types';
+
+export default class DYOFinder {
+  /**
+   * Current DTComponent associated to the Finder.
+   */
+  protected _component: DYOFinderComponentType;
+
+  /**
+   * Current DYOFinder configuration applied.
+   */
+  protected _configuration: DYOFinderConfiguration;
+
+  /**
+   * Set _component and _configuration properties.
+   *
+   * @param component
+   * @param configuration
+   */
+  constructor(component: DYOFinderComponentType, configuration: DYOFinderConfiguration) {
+    this._component = component;
+    this._configuration = configuration;
+  }
+
+  /**
+   * Getter for _component property.
+   */
+  getComponent(): DYOFinderComponentType {
+    return this._component;
+  }
+
+  /**
+   * Return an array of DTComponent from *_component* **_items** property filtered with a **filters** argument.
+   *
+   * Search filters can be applied on properties depending on the current _configuration provided.
+   *
+   * For each search filter provided, an object of specific operators is applied :
+   * * **BASIC OPERATORS**
+   * * **$eq** : The property must be strict equal to the filter value.
+   * * **$in** : The property must be included into the filter array.
+   * * **$nin** : The property must not be included into the filter array.
+   * * **$ne** : The property must be different to the filter value.
+   * * **EXTENDED OPERATORS** (meta only)
+   * * **$lte** : Number property only. The property must be lower or equal than the filter value.
+   * * **$gte** : Number property only. The property must be higher or equal than the filter array.
+   * * **$contains** : Array property only. The property must contain the filter value.
+   * * **$ncontains** : Array property only. The property must not contain the filter value.
+   *
+   * If many operators and / or many properties are passed into the **filters** argument, the logic operator applied is
+   * **AND**.
+   *
+   * @param filters Filters Object. The format is :
+   * { [property_1] : { [operator_1] : filter_value, [operator_2] : filter_value_2, ... }, [property_2] : { ... }, ... }
+   *
+   * For **objectSearch** properties, you have to pass the object key before the operator :
+   * { [property_1]: { [object_key1] : { [operator_1] : filter_value_1, ... }, [object_key2] : { ... }, ...  }, ... }
+   * @returns Array of DTComponent instance corresponding to the filters. Empty if no filter or invalid ones are passed.
+   */
+  execute<ITEM>(filters: DYOFinderFilters): ITEM[] {
+    const items = this._component.getAll();
+    const filteredItems = [];
+
+    for (const item of items) {
+      let validItem = !!(Object.keys(filters).length);
+
+      for (const [propKey, configProp] of Object.entries(this._configuration)) {
+        if (filters[propKey]) {
+          if (configProp.objectSearch) {
+            const objectValue = configProp.getValue(item, this.getComponent());
+            if (objectValue) {
+              for (const [filterK, filterV] of Object.entries(filters[propKey])) {
+                const metaValue = Object.prototype.hasOwnProperty.call(objectValue, filterK) ? objectValue[filterK] : undefined;
+                if (!this.checkAllValidFiltersForProp(metaValue, filterV, configProp.operators)) {
+                  validItem = false;
+                  break;
+                }
+              }
+            } else {
+              validItem = false;
+            }
+          } else if (!this.checkAllValidFiltersForProp(
+            (configProp.getValue(item, this.getComponent()) as StandardPrimitiveType),
+            filters[propKey],
+            configProp.operators,
+          )) {
+            validItem = false;
+          }
+        }
+      }
+
+      if (validItem) {
+        filteredItems.push(item);
+      }
+    }
+
+    return filteredItems;
+  }
+
+  private checkAllValidFiltersForProp = (
+    itemProp: StandardPrimitiveTypeWithArray,
+    operators: Partial<DYOFinderFilterOperator>,
+    validOperators: FilterOperatorType[],
+  ) => {
+    if (Object.keys(operators).length) {
+      for (const operator of Object.keys(operators)) {
+        if (!validOperators.includes(operator as FilterOperatorType)
+          || !this.validFiltersForItem(itemProp, operators[operator], operator as FilterOperatorType)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  };
+
+  private validFiltersForItem(
+    itemProp: StandardPrimitiveTypeWithArray,
+    filter: StandardPrimitiveTypeWithArray,
+    operator: FilterOperatorType,
+  ): boolean {
+    // $eq Filter
+    if (operator === FilterOperatorType.EQ) {
+      return itemProp === filter;
+    }
+    // $in Filter
+    if (operator === FilterOperatorType.IN) {
+      return filter ? (filter as Array<StandardPrimitiveType>).includes(itemProp as StandardPrimitiveType) : false;
+    }
+    // $nin Filter
+    if (operator === FilterOperatorType.NIN) {
+      return filter ? !(filter as Array<StandardPrimitiveType>).includes(itemProp as StandardPrimitiveType) : false;
+    }
+    // $ne Filter
+    /* c8 ignore next */
+    if (operator === FilterOperatorType.NE) {
+      return itemProp !== filter;
+    }
+    // $lte Filter
+    if (operator === FilterOperatorType.LTE) {
+      if (typeof itemProp === 'number' && typeof filter === 'number') {
+        return itemProp <= filter;
+      }
+      return false;
+    }
+    // $gte Filter
+    if (operator === FilterOperatorType.GTE) {
+      if (typeof itemProp === 'number' && typeof filter === 'number') {
+        return itemProp >= filter;
+      }
+      return false;
+    }
+    // $contains Filter
+    if (operator === FilterOperatorType.CONTAINS) {
+      return (itemProp && Array.isArray(itemProp))
+        ? (itemProp as Array<StandardPrimitiveType>).includes(filter as StandardPrimitiveType)
+        : false;
+    }
+    // $ncontains Filter
+    if (operator === FilterOperatorType.NCONTAINS) {
+      return (itemProp && Array.isArray(itemProp))
+        ? !(itemProp as Array<StandardPrimitiveType>).includes(filter as StandardPrimitiveType)
+        : false;
+    }
+
+    return false;
+  }
+}

package/src/libs/dix/DIXModule.module.ts

@@ -0,0 +1,98 @@
+import * as CoreComponents from '../../index';
+import { DIXObject } from '../../types';
+
+type DTElementClass = new (key: string, options: Record<string, unknown>) => CoreComponents.DTComponent;
+type DTBunchClass = new (key: string, items: unknown[], options: Record<string, unknown>) => CoreComponents.DTComponent;
+type DTManagerClass = new (key: string, items: unknown[], scopes: unknown[], options: Record<string, unknown>) => CoreComponents.DTComponent;
+type DTMasterClass = DTElementClass;
+
+export default class DTDIXModule extends CoreComponents.DTModule {
+  overrides: Record<string, unknown>;
+
+  constructor(overrides: Record<string, unknown> = {}) {
+    super('dix');
+    this.overrides = {
+      ...CoreComponents,
+      ...overrides,
+    };
+  }
+
+  syncNewItem(id: string, dix: Record<string, DIXObject>): CoreComponents.DTComponent | undefined {
+    const dixObject = dix[id];
+    let instance: CoreComponents.DTComponent | undefined;
+    const errorsEnabled = this._options.errors;
+
+    if (dixObject) {
+      switch (dixObject.componentType) {
+        case 'bunch':
+          try {
+            const UseClass = this.overrides[dixObject.useClass] as DTBunchClass;
+            instance = new UseClass(dixObject.key, [], { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+          } catch (err: unknown) {
+            if (errorsEnabled) {
+              const UseClass = this.overrides.DTBunch as DTBunchClass;
+              instance = new UseClass(dixObject.key, [], { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+            }
+            this.triggerError(new CoreComponents.DTError(
+              'dix_module_instance_error',
+              `Bunch Class ${dixObject.useClass} doesn't exist in DIX Module`,
+              this,
+            ));
+          }
+          break;
+        case 'manager':
+          try {
+            const UseClass = this.overrides[dixObject.useClass] as DTManagerClass;
+            instance = new UseClass(dixObject.key, [], [], { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+          } catch (err: unknown) {
+            if (errorsEnabled) {
+              const UseClass = this.overrides.DTManager as DTManagerClass;
+              instance = new UseClass(dixObject.key, [], [], { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+            }
+            this.triggerError(new CoreComponents.DTError(
+              'dix_module_instance_error',
+              `Manager Class ${dixObject.useClass} doesn't exist in DIX Module`,
+              this,
+            ));
+          }
+          break;
+        case 'master':
+          try {
+            const UseClass = this.overrides[dixObject.useClass] as DTMasterClass;
+            instance = new UseClass(dixObject.key, { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+          } catch (err: unknown) {
+            if (errorsEnabled) {
+              const UseClass = this.overrides.DTElement as DTMasterClass;
+              instance = new UseClass(dixObject.key, { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+            }
+            this.triggerError(new CoreComponents.DTError(
+              'dix_module_instance_error',
+              `Master Class ${dixObject.useClass} doesn't exist in DIX Module`,
+              this,
+            ));
+          }
+          break;
+        case 'element':
+        default:
+          try {
+            const UseClass = this.overrides[dixObject.useClass] as DTElementClass;
+            instance = new UseClass(dixObject.key, { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+            // console.log('Je test pour : ', instance.getKey(), instance.getId(), instance.getOptions(), id);
+          } catch (err: unknown) {
+            if (errorsEnabled) {
+              const UseClass = this.overrides.DTElement as DTElementClass;
+              instance = new UseClass(dixObject.key, { ...(JSON.parse(dixObject.options) ?? {}), syncId: id });
+            }
+            this.triggerError(new CoreComponents.DTError(
+              'dix_module_instance_error',
+              `Element Class ${dixObject.useClass} doesn't exist in DIX Module`,
+              this,
+            ));
+          }
+          break;
+      }
+    }
+
+    return instance;
+  }
+}

package/src/libs/player/DTPlayer.element.ts

@@ -1,7 +1,7 @@
 import { DTAcceptedMetaData } from '../../types';
-import DYOToolsElement from '../../core/DTElement';
+import DTElement from '../../core/DTElement';
 
-export default class DYOToolsPlayer<IComponentMeta extends DTAcceptedMetaData = DTAcceptedMetaData> extends DYOToolsElement<IComponentMeta> {
+export default class DTPlayer<IComponentMeta extends DTAcceptedMetaData = DTAcceptedMetaData> extends DTElement<IComponentMeta> {
   /**
    * Defining component domain to "player".
    */

package/src/libs/player/DTPlayer.manager.ts

@@ -1,48 +1,34 @@
-import DYOToolsManager from '../../core/DTManager';
-import DYOToolsPlayer from './DTPlayer.element';
-import { DTBunchFilters, DTManagerOptions, DTPlayerManagerSimpleConfiguration } from '../../types';
-import { DTPlayer } from '../../index';
+import DTManager from '../../core/DTManager';
+import DTPlayer from './DTPlayer.element';
+import { DTBunchFilters, DTPlayerManagerSimpleConfiguration } from '../../types';
 
-export default class DYOToolsPlayerManager extends DYOToolsManager<DYOToolsPlayer> {
+export default class DTPlayerManager extends DTManager<DTPlayer> {
   /**
    * Defining component domain to "player".
    */
   protected _domain = 'player';
 
   /**
-   * Applying the parent constructor. The key is **player** by default.
-   *
-   *
-   * The constructor uses a Configuration JSON Object, with following properties :
-   * * **players** : Default player configuration.
-   * If **players** is a number, it generates this number of DTPlayer instances and add it to the library.
-   * If **players** is an array of DTPlayer instances, it adds these to the library.
-   * * **errors** : Set **errors** option of the Manager.
-   *
-   * @param configuration DTPlayerManagerSimpleConfiguration Optional configuration to apply.
-   */
-  constructor(configuration?: DTPlayerManagerSimpleConfiguration) {
-    super('player');
-
-    // Simple Configuration
-    const finalConfig = configuration ?? {};
-    const finalOptions: DTManagerOptions = this._options;
-    if (finalConfig.players) {
-      if (typeof finalConfig.players === 'number' && finalConfig.players > 0) {
+    * Simply configure the manager with a configuration JSON Object
+    * **players** : Default player configuration.
+    * If **players** is a number, it generates this number of DTPlayer instances and add it to the library.
+    * If **players** is an array of DTPlayer instances, it adds these to the library.
+    *
+    * @param configuration DTPlayerManagerSimpleConfiguration Optional configuration to apply.
+    */
+  configure(configuration: DTPlayerManagerSimpleConfiguration) {
+    if (configuration.players) {
+      if (typeof configuration.players === 'number' && configuration.players > 0) {
         let i = 1;
-        while (i <= finalConfig.players) {
+        while (i <= configuration.players) {
           const player = new DTPlayer(`player${i}`);
           this._library.add(player);
           i += 1;
         }
-      } else if (Array.isArray(finalConfig.players)) {
-        this._library.addMany(finalConfig.players);
+      } else if (Array.isArray(configuration.players)) {
+        this._library.addMany(configuration.players);
       }
     }
-
-    if (finalConfig.errors) {
-      finalOptions.errors = finalConfig.errors;
-    }
   }
 
   /**
@@ -50,7 +36,7 @@ export default class DYOToolsPlayerManager extends DYOToolsManager<DYOToolsPlaye
    *
    * @param id string _id property of the DTPlayer instance to get.
    */
-  getPlayer(id: string): DYOToolsPlayer {
+  getPlayer(id: string): DTPlayer {
     return this._library.get(id);
   }
 
@@ -59,7 +45,7 @@ export default class DYOToolsPlayerManager extends DYOToolsManager<DYOToolsPlaye
    *
    * @param player DYOToolsPlayer instance to add.
    */
-  addPlayer(player: DYOToolsPlayer): void {
+  addPlayer(player: DTPlayer): void {
     this._library.add(player);
   }
 
@@ -78,7 +64,7 @@ export default class DYOToolsPlayerManager extends DYOToolsManager<DYOToolsPlaye
    * @see [find](#find) method for search specifications.
    * @param filters DTBunchFilters filters to apply.
    */
-  findPlayers(filters: Partial<DTBunchFilters>): DYOToolsPlayer[] {
+  findPlayers(filters: Partial<DTBunchFilters>): DTPlayer[] {
     return this._library.find(filters);
   }
 }

package/src/types/core.ts

@@ -1,5 +1,5 @@
 import { DTBunch, DTComponent } from '../index';
-import DYOToolsElement from '../core/DTElement';
+import DTElement from '../core/DTElement';
 
 /** Constants Enum * */
 export enum FilterOperatorType {
@@ -62,7 +62,12 @@ export interface DTComponentOptions {
    * Default *false*. If *true*, no exception is thrown when an error occurred, a new DTError instance is
    * added to the _errors property array instead. If *false*, throw the exception with a DTError instance.
    */
-  errors: boolean
+  errors: boolean,
+  /**
+   * Default undefined. If specified, the string argument passed will be the id of the new DTComponent.
+   * Used to synchronize ids between to instances (with the DIX Module). Be careful when using.
+   */
+  syncId: string | undefined
 }
 
 export interface DTComponentToObject {
@@ -71,6 +76,15 @@ export interface DTComponentToObject {
   type: string
 }
 
+export interface DTComponentToDIXObject {
+  key: string
+  componentType: string,
+  domain?: string
+  subKind?: string
+  meta?: string
+  owner?: string
+}
+
 /** DTComponentWithMeta interfaces * */
 export type DTAcceptedMetaData = Record<
 string,
@@ -126,9 +140,15 @@ export interface DTBunchFilters {
   meta: Record<string, Partial<DYOFinderFilterOperatorBase & DYOFinderFilterOperatorAdvanced>>
 }
 
+export interface DTBunchToDIXObject extends DTComponentToDIXObject {
+  componentType: 'bunch'
+  items: string[]
+  scope?: string
+}
+
 /** DTManager interfaces * */
-export type DTManagerItemsType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = Record<string, DTManagerItemType<IBunchItem>>;
-export type DTManagerItemType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = {
+export type DTManagerItemsType<IBunchItem extends DTElement<DTAcceptedMetaData>> = Record<string, DTManagerItemType<IBunchItem>>;
+export type DTManagerItemType<IBunchItem extends DTElement<DTAcceptedMetaData>> = {
   scope: string,
   item: DTBunch<IBunchItem>,
 };
@@ -167,3 +187,18 @@ export interface DTMasterToObject extends DTComponentToObject {
   actions: Array<DTComponentToObject>,
   modules: Array<DTModuleToObject>,
 }
+
+/** Final DIX Object typing * */
+export interface DIXObject {
+  useClass: string,
+  key: string
+  componentType: string,
+  options: string
+  meta?: string
+  owner?: string
+  items?: string[]
+  library?: string
+  scope?: string,
+  scopes?: string[],
+  [key: string]: unknown,
+}

package/src/types/index.ts

@@ -1,2 +1,2 @@
-export * from './core';
-export * from './player';
+export * from './core';
+export * from './player';

package/src/types/player.ts

@@ -2,5 +2,4 @@ import { DTPlayer } from '../index';
 
 export interface DTPlayerManagerSimpleConfiguration {
   players?: number | DTPlayer[];
-  errors?: boolean;
 }