dyo-tools 0.4.0 → 0.4.1

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

@@ -1,98 +0,0 @@
-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 +0,0 @@
-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,70 +0,0 @@
-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);
-  }
-}

package/src/types/core.ts

@@ -1,204 +0,0 @@
-import { DTBunch, DTComponent } from '../index';
-import DTElement 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,
-  /**
-   * 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 {
-  id: string
-  key: string
-  type: string
-}
-
-export interface DTComponentToDIXObject {
-  key: string
-  componentType: string,
-  domain?: string
-  subKind?: string
-  meta?: string
-  owner?: 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>>
-}
-
-export interface DTBunchToDIXObject extends DTComponentToDIXObject {
-  componentType: 'bunch'
-  items: string[]
-  scope?: string
-}
-
-/** DTManager interfaces * */
-export type DTManagerItemsType<IBunchItem extends DTElement<DTAcceptedMetaData>> = Record<string, DTManagerItemType<IBunchItem>>;
-export type DTManagerItemType<IBunchItem extends DTElement<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>,
-}
-
-/** 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 +0,0 @@
-export * from './core';
-export * from './player';

package/src/types/player.ts

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

package/test/core/DTAction.double.ts

@@ -1,62 +0,0 @@
-import {DTAction} from "../../src";
-import {DTComponentToObject} from "../../src/types";
-
-/** ****************** STUB PROPERTIES CONSTANTS
- * Fixed properties to use with double classes, avoid auto generated and easy checking on test
- * **** */
-export const IDTest = 'DTAction-id-1234567';
-export const KeyTest = 'DTAction-key-1234567';
-
-// Specific Manager constants
-export const action1IDTest = `${IDTest}_1`;
-export const action1KeyTest = `${KeyTest}_1`;
-
-export const action1ToObject: DTComponentToObject = {
-  id: action1IDTest,
-  key: action1KeyTest,
-  type: 'action'
-}
-
-/** ****************** HELPER TEST CLASS
- * Helper test class, inherits the main component
- * Providing methods to property access and other facilities, in order to avoid using class methods
- * **** */
-export class DTActionTest extends DTAction<string> {
-
-  constructor(
-    id: string = IDTest,
-    key: string = KeyTest,
-  ) {
-    super(key);
-    this._id = id;
-  }
-
-  async execute(payload: string): Promise<void> {
-    throw `${this._key} : ${payload}`;
-  }
-}
-
-
-/** ****************** STUB CLASS
- * Stub class, for using in other component
- * **** */
-export class DTActionStub extends DTActionTest {
-  constructor() {
-    super();
-    this._id = IDTest;
-    this._key = KeyTest;
-    this._errors = [];
-  }
-
-  _setId(id: string) {
-    this._id = id;
-  }
-
-  _setKey(key: string) {
-    this._key = key;
-  }
-}
-
-/** ****************** HELPER METHODS
- * Additional helper methods to use with testing
- * **** */

package/test/core/DTAction.spec.ts

@@ -1,68 +0,0 @@
-import {DTAction, DTComponent} from "../../src";
-import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
-import {DTActionTest, IDTest, KeyTest} from "./DTAction.double";
-
-/** *********************** TESTS SUITES ****************************** */
-describe('class DTAction' +
-  '', () => {
-  let actionTest: DTActionTest;
-
-  beforeEach(() => {
-    actionTest = new DTActionTest();
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('inheritance', () => {
-    test('check good inheritance for class', () => {
-      expect(DTAction.prototype instanceof DTComponent).toBeTruthy();
-    });
-  });
-
-  describe('_componentType', () => {
-    test('componentType must be "action"', () => {
-      expect(actionTest.getComponentType()).toBe('action');
-    });
-  });
-
-  describe('getMaster', () => {
-    test('call get context with master accessor', () => {
-      const getContextSpy = jest.spyOn(actionTest, 'getContext');
-      
-      actionTest.getMaster();
-
-      expect(getContextSpy.mock.calls.length).toBe(1);
-      expect(getContextSpy.mock.calls[0][0]).toBe('master');
-    });
-  });
-
-  describe('execute', () => {
-    test('throw payload in test implementation', async () => {
-      const payload = `execute action`;
-      const expectedPayload = `${KeyTest} : execute action`;
-
-      await expect(actionTest.execute(payload)).rejects.toBe(expectedPayload);
-    });
-  });
-
-  describe('toString', () => {
-    test('string output standard', () => {
-      const toStringAction = actionTest.toString();
-
-      expect(toStringAction).toBe(`Component ${KeyTest} - Type: Action`);
-    });
-  });
-
-  describe('toObject', () => {
-    test('toObject output standard', () => {
-      const toObjectAction: any = actionTest.toObject();
-
-      expect(Object.keys(toObjectAction)).toStrictEqual(['id', 'key', 'type']);
-      expect(toObjectAction.id).toBe(IDTest);
-      expect(toObjectAction.key).toBe(KeyTest);
-      expect(toObjectAction.type).toBe('action');
-    });
-  });
-});

package/test/core/DTBunch.double.ts

@@ -1,175 +0,0 @@
-import {DTBunch} from '../../src';
-import {bunchDefaultOptions, bunchDefaultOptions as DTBunchDefaultOptions} from '../../src/constants';
-import {
-  HaileiMetaData,
-  IldressMetaData,
-  IMetaDataTest,
-  MaydenaMetaData,
-  MeldrineMetaData,
-  YssaliaMetaData,
-} from './DTComponentWithMeta.double';
-import {DIXObject, DTBunchOptions, DTElementToObject} from '../../src/types';
-import {
-  DTElementStub,
-  HaileiIdTest,
-  HaileiKeyTest,
-  HaileiToObjectTest,
-  IldressIdTest,
-  IldressKeyTest,
-  IldressToObjectTest,
-  MaydenaIdTest,
-  MaydenaKeyTest,
-  MaydenaToObjectTest,
-  MeldrineIdTest,
-  MeldrineKeyTest,
-  MeldrineToObjectTest,
-  YssaliaIdTest,
-  YssaliaKeyTest,
-  YssaliaToObjectTest,
-} from './DTElement.double';
-
-/** ****************** STUB PROPERTIES CONSTANTS
- * Fixed properties to use with double classes, avoid auto generated and easy checking on test
- * **** */
-// Global Bunch constants
-export const IDTest = 'DTBunch-id-1234567';
-export const IDTestLibrary = 'DTBunch-id-library-1234567';
-export const KeyTest = 'DTBunch-key-1234567';
-
-// Specific Bunch constants
-export const bunch1IdTest = `${IDTest}_1`;
-export const bunch1toObjectTest = {
-  id: bunch1IdTest, key: KeyTest, type: 'bunch', items: [
-    HaileiToObjectTest,
-    MeldrineToObjectTest,
-    MaydenaToObjectTest,
-    IldressToObjectTest,
-    YssaliaToObjectTest
-  ],
-};
-export const bunch2IdTest = `${IDTest}_2`;
-export const bunch2toObjectTest = {
-  id: bunch2IdTest, key: KeyTest, type: 'bunch', items: [],
-};
-export const bunch3IdTest = `${IDTest}_3`;
-export const bunch3toObjectTest = {
-  id: bunch3IdTest, key: KeyTest, type: 'bunch', items: [],
-};
-
-
-/** ****************** HELPER TEST CLASS
- * Helper test class, inherits the main component
- * Providing methods to property access and other facilities, in order to avoid using class methods
- * **** */
-export class DTBunchTest extends DTBunch<DTElementStub, IMetaDataTest> {
-
-  constructor(
-    id: string = IDTest,
-    key: string = KeyTest,
-    items: DTElementStub[] = [],
-    options: Partial<DTBunchOptions> = bunchDefaultOptions,
-    owner: string | undefined = undefined,
-  ) {
-    super(key, items, options);
-    this._id = id;
-    this._owner = owner;
-  }
-
-  _getFinder() {
-    return this._finder;
-  }
-}
-
-/** ****************** STUB CLASS
- * Stub class, for using in other component
- * **** */
-export class DTBunchStub extends DTBunch<DTElementStub> {
-  constructor(items: Array<DTElementStub> = [], options: Partial<DTBunchOptions> = {}) {
-    super();
-    this._id = IDTest;
-    this._key = KeyTest;
-    this._errors = [];
-    this._items = items;
-    this._options = {
-      ...DTBunchDefaultOptions,
-      ...options,
-    };
-  }
-
-  _setId(id: string) {
-    this._id = id;
-  }
-}
-
-// Specific Stub Library for Manager
-export class DTBunchStubLibrary extends DTBunch<DTElementStub> {
-  constructor(items: Array<DTElementStub> = []) {
-    super();
-    this._id = IDTestLibrary;
-    this._key = 'library';
-    this._errors = [];
-    this._items = items;
-    this._options = {
-      ...DTBunchDefaultOptions,
-      virtualContainer: true,
-    };
-  }
-}
-
-/** ****************** HELPER METHODS
- * Additional helper methods to use with testing
- * **** */
-
-// Function to generate Stub DTElement collection
-export const generateStubElements = (numberElements: number, owner?: string): DTElementStub[] => {
-  const mockedElements: DTElementStub[] = [];
-  const mockedData: Array<{ id: string, key: string, meta: IMetaDataTest, toObject: DTElementToObject<IMetaDataTest> }> = [
-    {
-      id: HaileiIdTest,
-      key: HaileiKeyTest,
-      meta: HaileiMetaData,
-      toObject: HaileiToObjectTest,
-    },
-    {
-      id: MeldrineIdTest,
-      key: MeldrineKeyTest,
-      meta: MeldrineMetaData,
-      toObject: MeldrineToObjectTest,
-    },
-    {
-      id: MaydenaIdTest,
-      key: MaydenaKeyTest,
-      meta: MaydenaMetaData,
-      toObject: MaydenaToObjectTest,
-    },
-    {
-      id: IldressIdTest,
-      key: IldressKeyTest,
-      meta: IldressMetaData,
-      toObject: IldressToObjectTest,
-    },
-    {
-      id: YssaliaIdTest,
-      key: YssaliaKeyTest,
-      meta: YssaliaMetaData,
-      toObject: YssaliaToObjectTest,
-    },
-  ];
-
-  for (let i = 0; i < numberElements; i++) {
-    const selectedData = i % 5;
-    const mockedElement = new DTElementStub(
-      0,
-      (mockedData[selectedData].id + "-" + i),
-      mockedData[selectedData].key,
-      mockedData[selectedData].meta,
-      owner,
-      mockedData[selectedData].toObject,
-    );
-
-    mockedElements.push(mockedElement);
-  }
-
-  return mockedElements;
-};
-