dyo-tools 0.2.0 → 0.3.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/player/DTPlayer.element.ts

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

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

@@ -0,0 +1,84 @@
+import DYOToolsManager from '../../core/DTManager';
+import DYOToolsPlayer from './DTPlayer.element';
+import { DTBunchFilters, DTManagerOptions, DTPlayerManagerSimpleConfiguration } from '../../types';
+import { DTPlayer } from '../../index';
+
+export default class DYOToolsPlayerManager extends DYOToolsManager<DYOToolsPlayer> {
+  /**
+   * 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) {
+        let i = 1;
+        while (i <= finalConfig.players) {
+          const player = new DTPlayer(`player${i}`);
+          this._library.add(player);
+          i += 1;
+        }
+      } else if (Array.isArray(finalConfig.players)) {
+        this._library.addMany(finalConfig.players);
+      }
+    }
+
+    if (finalConfig.errors) {
+      finalOptions.errors = finalConfig.errors;
+    }
+  }
+
+  /**
+   * Get one DTPlayer instance by id into the library.
+   *
+   * @param id string _id property of the DTPlayer instance to get.
+   */
+  getPlayer(id: string): DYOToolsPlayer {
+    return this._library.get(id);
+  }
+
+  /**
+   * Add one DTPlayer instance into the library.
+   *
+   * @param player DYOToolsPlayer instance to add.
+   */
+  addPlayer(player: DYOToolsPlayer): void {
+    this._library.add(player);
+  }
+
+  /**
+   * Remove one DTPlayer instance by id from the library.
+   *
+   * @param id string _id property of the DTPlayer instance to remove.
+   */
+  removePlayer(id: string): void {
+    this._library.remove(id);
+  }
+
+  /**
+   * Find DTPlayer instances into the Library.
+   *
+   * @see [find](#find) method for search specifications.
+   * @param filters DTBunchFilters filters to apply.
+   */
+  findPlayers(filters: Partial<DTBunchFilters>): DYOToolsPlayer[] {
+    return this._library.find(filters);
+  }
+}

package/src/types/core.ts

@@ -0,0 +1,169 @@
+import { DTBunch, DTComponent } from '../index';
+import DYOToolsElement from '../core/DTElement';
+
+/** Constants Enum * */
+export enum FilterOperatorType {
+  EQ = '$eq',
+  IN = '$in',
+  NIN = '$nin',
+  NE = '$ne',
+  LTE = '$lte',
+  GTE = '$gte',
+  CONTAINS = '$contains',
+  NCONTAINS = '$ncontains',
+}
+
+/** Common Types * */
+export type StandardPrimitiveType = string | number | boolean | null | undefined;
+export type StandardPrimitiveTypeWithArray = string | number | boolean | Array<string | number | boolean> | null | undefined;
+
+/** DYO Finder interfaces * */
+export type DYOFinderConfiguration = Record<string, DYOFinderConfigurationProp>;
+export type DYOFinderComponentType = DTComponent & {
+  getAll: () => DTComponent[],
+};
+
+export interface DYOFinderConfigurationPropDefault {
+  operators: FilterOperatorType[],
+  getValue: (item: DTComponent, ctx?: DTComponent) => StandardPrimitiveType,
+  objectSearch: false,
+}
+
+export interface DYOFinderConfigurationPropObjectSearch {
+  operators: FilterOperatorType[],
+  getValue: (item: DTComponent, ctx?: DTComponent) => Record<string, StandardPrimitiveTypeWithArray>,
+  objectSearch: true,
+}
+export type DYOFinderConfigurationProp = DYOFinderConfigurationPropDefault | DYOFinderConfigurationPropObjectSearch;
+
+export interface DYOFinderFilterOperatorBase {
+  [FilterOperatorType.EQ]: StandardPrimitiveType
+  [FilterOperatorType.IN]: Array<StandardPrimitiveType>
+  [FilterOperatorType.NIN]: Array<StandardPrimitiveType>
+  [FilterOperatorType.NE]: StandardPrimitiveType
+}
+export interface DYOFinderFilterOperatorAdvanced {
+  [FilterOperatorType.LTE]: number
+  [FilterOperatorType.GTE]: number
+  [FilterOperatorType.CONTAINS]: StandardPrimitiveType
+  [FilterOperatorType.NCONTAINS]: StandardPrimitiveType
+}
+
+export type DYOFinderFilterOperator = DYOFinderFilterOperatorBase & DYOFinderFilterOperatorAdvanced;
+export type DYOFinderFilterOperatorArgument = Partial<DYOFinderFilterOperator | Record<string, Partial<DYOFinderFilterOperator>>>;
+export type DYOFinderFilters = Record<string, DYOFinderFilterOperatorArgument>;
+
+/** DTComponent interfaces * */
+/**
+ * DTComponent default options configuration.
+ */
+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
+}
+
+export interface DTComponentToObject {
+  id: string
+  key: string
+  type: string
+}
+
+/** DTComponentWithMeta interfaces * */
+export type DTAcceptedMetaData = Record<
+string,
+StandardPrimitiveTypeWithArray
+>;
+
+/** DTElement interfaces * */
+export interface DTElementToObject<IComponentMeta> extends DTComponentToObject {
+  owner?: string
+  meta?: Partial<IComponentMeta>
+}
+
+/** DTBunch interfaces * */
+/**
+ * DTBunch option configuration.
+ */
+export interface DTBunchOptions extends DTComponentOptions {
+  /**
+   * Default *false*. If *true*, an error occurred when adding a new DTElement with the same key of an
+   * existing element into the bunch.
+   */
+  uniqueKey: boolean
+  /**
+   * Default *false*. If *true*, when a new DTElement is added at existing index (using **addAtIndex**
+   * or **addManyAtIndex** method), this component replaces the old one. If *false*, this component is added at the specified
+   * index and other existing component are reindexed with the following index.
+   */
+  replaceIndex: boolean
+  /**
+   * Default *false*. If *true*, when a new DTElement is added, the owner of this element becomes
+   * automatically the current bunch owner.
+   */
+  inheritOwner: boolean
+  /**
+   * Default *false*. If *true*, the container is not changed when a new DTElement is added.
+   * If *false*, when a new DTElement is added, the container of this element becomes automatically the current bunch instance
+   * and the element is removed from the old container Component (if defined).
+   */
+  virtualContainer: boolean
+}
+
+export interface DTBunchToObject<IComponentMeta> extends DTComponentToObject {
+  items: Array<DTElementToObject<DTAcceptedMetaData>>
+  owner?: string
+  meta?: Partial<IComponentMeta>
+}
+
+export interface DTBunchFilters {
+  id: Partial<DYOFinderFilterOperatorBase>
+  key: Partial<DYOFinderFilterOperatorBase>
+  container: Partial<DYOFinderFilterOperatorBase>
+  owner: Partial<DYOFinderFilterOperatorBase>
+  meta: Record<string, Partial<DYOFinderFilterOperatorBase & DYOFinderFilterOperatorAdvanced>>
+}
+
+/** DTManager interfaces * */
+export type DTManagerItemsType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = Record<string, DTManagerItemType<IBunchItem>>;
+export type DTManagerItemType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = {
+  scope: string,
+  item: DTBunch<IBunchItem>,
+};
+
+export interface DTManagerFilters extends DYOFinderFilters {
+  id: Partial<DYOFinderFilterOperatorBase>
+  key: Partial<DYOFinderFilterOperatorBase>
+  owner: Partial<DYOFinderFilterOperatorBase>
+  scope: Partial<DYOFinderFilterOperatorBase>
+  meta: Record<string, Partial<DYOFinderFilterOperatorBase & DYOFinderFilterOperatorAdvanced>>
+}
+
+/**
+ * DTManager option configuration.
+ */
+export interface DTManagerOptions extends DTComponentOptions {
+  /**
+   * Default *false*. If *true*, when a bunch instance is removed from the Manager _items, the process performs also
+   * a removal from the Manager Library of all DTElement instances of the bunch.
+   */
+  libraryDeletion: boolean,
+}
+
+export interface DTManagerToObject extends DTComponentToObject {
+  items: Array<DTBunchToObject<DTAcceptedMetaData> & { scope: string }>
+}
+
+/** DTModule interfaces * */
+export interface DTModuleToObject extends DTComponentToObject {
+  enabled: boolean
+}
+
+/** DTMaster interfaces * */
+export interface DTMasterToObject extends DTComponentToObject {
+  managers: Array<DTManagerToObject>,
+  actions: Array<DTComponentToObject>,
+  modules: Array<DTModuleToObject>,
+}