dyo-tools 0.3.0 → 0.4.0

package/src/core/DTModule.ts

@@ -1,90 +1,96 @@
-import DYOToolsComponent from './DTComponent';
-import { DTModuleToObject } from '../types';
-import DYOToolsMaster from './DTMaster';
-
-export default class DYOToolsModule extends DYOToolsComponent {
-  /**
-   * Defining component type to "module".
-   */
-  protected _componentType: string = 'module';
-
-  /**
-   * Defining if the module is enabled or not.
-   * @protected
-   */
-  protected _enabled: boolean;
-
-  /**
-   * Applying the parent constructor, and initializing _enabled property to true by default.
-   *
-   * @param key
-   */
-  constructor(key?: string) {
-    super(key);
-
-    this._enabled = true;
-  }
-
-  /**
-   * Returns Master component from context, or undefined.
-   */
-  getMaster(): DYOToolsMaster | undefined {
-    return this.getContext<DYOToolsMaster>('master');
-  }
-
-  /**
-   * Getter for the _enabled property.
-   */
-  isEnabled(): boolean {
-    return this._enabled;
-  }
-
-  /**
-   * Change _enabled property to true.
-   */
-  enable(): void {
-    this._enabled = true;
-  }
-
-  /**
-   * Change _enabled property to false.
-   */
-  disable(): void {
-    this._enabled = false;
-  }
-
-  /**
-   * Return String representation of the Module instance.
-   *
-   * @returns String representation of the Module.
-   */
-  toString(): string {
-    let extraLabel: string = '';
-
-    if (!this._enabled) {
-      extraLabel = ' - Disabled';
-    }
-
-    return `Component ${this._key} - Type: Module${extraLabel}`;
-  }
-
-  /**
-   * Return JSON Object representation of the Module instance.
-   *
-   * JSON Object returned has the following structure :
-   * * **id** : _id property of the Module.
-   * * **key** : _key property of the Module.
-   * * **type** : _componentType property of the Module.
-   * * **enabled** : _enabled property of the Module.
-   *
-   * @returns JSON Object representation of the Module.
-   */
-  toObject(): DTModuleToObject {
-    return {
-      id: this._id,
-      key: this._key,
-      type: this._componentType,
-      enabled: this._enabled,
-    };
-  }
-}
+import DTComponent from './DTComponent';
+import { DIXObject, DTModuleToObject } from '../types';
+import DTMaster from './DTMaster';
+
+export default class DTModule extends DTComponent {
+  /**
+   * Defining component type to "module".
+   */
+  protected _componentType: string = 'module';
+
+  /**
+   * Defining if the module is enabled or not.
+   * @protected
+   */
+  protected _enabled: boolean;
+
+  /**
+   * Applying the parent constructor, and initializing _enabled property to true by default.
+   *
+   * @param key
+   */
+  constructor(key?: string) {
+    super(key);
+
+    this._enabled = true;
+  }
+
+  /**
+   * Returns Master component from context, or undefined.
+   */
+  getMaster(): DTMaster | undefined {
+    return this.getContext<DTMaster>('master');
+  }
+
+  /**
+   * Getter for the _enabled property.
+   */
+  isEnabled(): boolean {
+    return this._enabled;
+  }
+
+  /**
+   * Change _enabled property to true.
+   */
+  enable(): void {
+    this._enabled = true;
+  }
+
+  /**
+   * Change _enabled property to false.
+   */
+  disable(): void {
+    this._enabled = false;
+  }
+
+  /**
+   * Return String representation of the Module instance.
+   *
+   * @returns String representation of the Module.
+   */
+  toString(): string {
+    let extraLabel: string = '';
+
+    if (!this._enabled) {
+      extraLabel = ' - Disabled';
+    }
+
+    return `Component ${this._key} - Type: Module${extraLabel}`;
+  }
+
+  /**
+   * Return JSON Object representation of the Module instance.
+   *
+   * JSON Object returned has the following structure :
+   * * **id** : _id property of the Module.
+   * * **key** : _key property of the Module.
+   * * **type** : _componentType property of the Module.
+   * * **enabled** : _enabled property of the Module.
+   *
+   * @returns JSON Object representation of the Module.
+   */
+  toObject(): DTModuleToObject {
+    return {
+      id: this._id,
+      key: this._key,
+      type: this._componentType,
+      enabled: this._enabled,
+    };
+  }
+
+  toDIXObject(): Record<string, DIXObject> {
+    return undefined;
+  }
+
+  updateFromDix(): void {}
+}

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,9 +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';
-}
+import { DTAcceptedMetaData } from '../../types';
+import DTElement from '../../core/DTElement';
+
+export default class DTPlayer<IComponentMeta extends DTAcceptedMetaData = DTAcceptedMetaData> extends DTElement<IComponentMeta> {
+  /**
+   * Defining component domain to "player".
+   */
+  protected _domain = 'player';
+}

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

@@ -1,84 +1,70 @@
-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);
-  }
-}
+import DTManager from '../../core/DTManager';
+import DTPlayer from './DTPlayer.element';
+import { DTBunchFilters, DTPlayerManagerSimpleConfiguration } from '../../types';
+
+export default class DTPlayerManager extends DTManager<DTPlayer> {
+  /**
+   * Defining component domain to "player".
+   */
+  protected _domain = 'player';
+
+  /**
+    * 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 <= configuration.players) {
+          const player = new DTPlayer(`player${i}`);
+          this._library.add(player);
+          i += 1;
+        }
+      } else if (Array.isArray(configuration.players)) {
+        this._library.addMany(configuration.players);
+      }
+    }
+  }
+
+  /**
+   * Get one DTPlayer instance by id into the library.
+   *
+   * @param id string _id property of the DTPlayer instance to get.
+   */
+  getPlayer(id: string): DTPlayer {
+    return this._library.get(id);
+  }
+
+  /**
+   * Add one DTPlayer instance into the library.
+   *
+   * @param player DYOToolsPlayer instance to add.
+   */
+  addPlayer(player: DTPlayer): 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>): DTPlayer[] {
+    return this._library.find(filters);
+  }
+}