dyo-tools 0.1.0 → 0.3.0

package/test/libs/DYOFinder.spec.ts

@@ -0,0 +1,194 @@
+import {
+  afterEach, beforeEach, describe, expect, jest, test,
+} from '@jest/globals';
+import { DTBunchStub, IDTest } from '../core/DTBunch.double';
+import DYOFinderTest, { DefaultConfiguration, generateComponent } from './DYOFinder.double';
+import { FilterOperatorType } from '../../src/types';
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOFinder', () => {
+  let bunchStubToFind: DTBunchStub;
+  let finder: DYOFinderTest;
+
+  beforeEach(() => {
+    bunchStubToFind = generateComponent();
+    finder = new DYOFinderTest(bunchStubToFind, DefaultConfiguration);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('constructor()', () => {
+    test('simple initialisation', () => {
+      const newFinder = new DYOFinderTest(bunchStubToFind, DefaultConfiguration);
+
+      expect(newFinder.th_get_component().getId()).toBe(IDTest);
+      expect(newFinder.th_get_configuration()).toStrictEqual(DefaultConfiguration);
+    });
+  });
+
+  describe('execute()', () => {
+    const finderExecutionTestValue = (results: any): [number, []] => [
+      results.length,
+      results.map((result) => result.parentIndex),
+    ];
+
+    test('find items - $eq operator case', () => {
+      // String prop
+      expect(finderExecutionTestValue(finder.execute({ propString: { $eq: 'item_prime' } }))).toStrictEqual([2, [0, 1]]);
+      expect(finderExecutionTestValue(finder.execute({ propString: { $eq: 'invalid' } }))).toStrictEqual([0, []]);
+      // Number prop
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $eq: 17 } }))).toStrictEqual([2, [0, 3]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $eq: 24 } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $eq: '17' } }))).toStrictEqual([0, []]);
+      // Array prop
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $eq: 'tag1' } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $eq: undefined } }))).toStrictEqual([1, [3]]);
+      // Boolean prop
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $eq: true } }))).toStrictEqual([3, [0, 2, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $eq: false } }))).toStrictEqual([2, [1, 3]]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $eq: 'false' } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $eq: null } }))).toStrictEqual([0, []]);
+      // Object prop
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $eq: 'value' } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $eq: "{ data: 'value' }" } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $eq: null } }))).toStrictEqual([2, [3, 4]]);
+    });
+
+    test('find items - $ne operator case', () => {
+      // String prop
+      expect(finderExecutionTestValue(finder.execute({ propString: { $ne: 'item_prime' } }))).toStrictEqual([3, [2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propString: { $ne: 'invalid' } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      // Number prop
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $ne: 17 } }))).toStrictEqual([3, [1, 2, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $ne: 24 } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $ne: '17' } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      // Array prop
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $ne: 'tag1' } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $ne: undefined } }))).toStrictEqual([4, [0, 1, 2, 4]]);
+      // Boolean prop
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $ne: true } }))).toStrictEqual([2, [1, 3]]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $ne: false } }))).toStrictEqual([3, [0, 2, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $ne: 'false' } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $ne: null } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      // Object prop
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $ne: 'value' } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $ne: "{ data: 'value' }" } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $ne: null } }))).toStrictEqual([3, [0, 1, 2]]);
+    });
+
+    test('find items - $in operator case', () => {
+      // String prop
+      expect(finderExecutionTestValue(finder.execute({ propString: { $in: ['item_prime', 'item_second'] } }))).toStrictEqual([4, [0, 1, 2, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propString: { $in: ['item_third', 'invalid', false] } }))).toStrictEqual([1, [3]]);
+      // Number prop
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $in: [17, 19] } }))).toStrictEqual([3, [0, 1, 3]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $in: ['17', 24, false] } }))).toStrictEqual([0, []]);
+      // Array prop
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $in: ['tag1'] } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $in: ['tag1', 'tag2', undefined] } }))).toStrictEqual([1, [3]]);
+      // Boolean prop
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $in: [true, false] } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $in: ['true', 'false', null] } }))).toStrictEqual([0, []]);
+      // Object prop
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $in: ['value'] } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $in: null } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $in: [null] } }))).toStrictEqual([2, [3, 4]]);
+    });
+
+    test('find items - $nin operator case', () => {
+      // String prop
+      expect(finderExecutionTestValue(finder.execute({ propString: { $nin: ['item_prime', 'item_second'] } }))).toStrictEqual([1, [3]]);
+      expect(finderExecutionTestValue(finder.execute({ propString: { $nin: ['item_third', 'invalid', false] } }))).toStrictEqual([4, [0, 1, 2, 4]]);
+      // Number prop
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $nin: [17, 19] } }))).toStrictEqual([2, [2, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $nin: ['17', 24, false] } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      // Array prop
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $nin: ['tag1'] } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $nin: ['tag1', 'tag2', undefined] } }))).toStrictEqual([4, [0, 1, 2, 4]]);
+      // Boolean prop
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $nin: [true, false] } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propBoolean: { $nin: ['true', 'false', null] } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      // Object prop
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $nin: ['value'] } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $nin: null } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propObject: { $nin: [null] } }))).toStrictEqual([3, [0, 1, 2]]);
+    });
+
+    test('find items - $lte operator case', () => {
+      // Number prop
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $lte: 23 } }))).toStrictEqual([4, [0, 1, 2, 3]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $lte: 1000 } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $lte: null } }))).toStrictEqual([0, []]);
+    });
+
+    test('find items - $gte operator case', () => {
+      // Number prop
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $gte: 23 } }))).toStrictEqual([2, [2, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $gte: -1000 } }))).toStrictEqual([5, [0, 1, 2, 3, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propNumber: { $gte: null } }))).toStrictEqual([0, []]);
+    });
+
+    test('find items - $contains operator case', () => {
+      // Array prop
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $contains: 'tag1' } }))).toStrictEqual([3, [0, 1, 2]]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $contains: undefined } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $contains: 'invalid_tag' } }))).toStrictEqual([0, []]);
+    });
+
+    test('find items - $ncontains operator case', () => {
+      // Array prop
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $ncontains: 'tag1' } }))).toStrictEqual([1, [4]]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $ncontains: undefined } }))).toStrictEqual([4, [0, 1, 2, 4]]);
+      expect(finderExecutionTestValue(finder.execute({ propArray: { $ncontains: 'invalid_tag' } }))).toStrictEqual([4, [0, 1, 2, 4]]);
+    });
+
+    test('disable filters by configuration', () => {
+      finder.th_set_configuration({
+        propString: {
+          operators: [FilterOperatorType.NE],
+          getValue: (item: any) => item.getPropString(),
+          objectSearch: false,
+        },
+      });
+
+      expect(finderExecutionTestValue(finder.execute({ propString: { $eq: 'item_prime' } }))).toStrictEqual([0, []]);
+      expect(finderExecutionTestValue(finder.execute({ propString: { $in: ['item_prime', 'item_second'] } }))).toStrictEqual([0, []]);
+    });
+
+    test('returns no items when no filter passed', () => {
+      expect(finderExecutionTestValue(finder.execute({}))).toStrictEqual([0, []]);
+    });
+
+    test('find items with object search property', () => {
+      expect(finderExecutionTestValue(finder.execute(
+        { propMeta: { meta1: { $eq: 'value1' } } },
+      ))).toStrictEqual([2, [0, 1]]);
+      expect(finderExecutionTestValue(finder.execute(
+        { propMeta: { meta2: { $in: ['value2', 'value1'] } } },
+      ))).toStrictEqual([2, [1, 2]]);
+      expect(finderExecutionTestValue(finder.execute(
+        { propMeta: { meta1: { $ne: 'value1' } } },
+      ))).toStrictEqual([2, [2, 4]]);
+      expect(finderExecutionTestValue(finder.execute(
+        { propMeta: { meta1: { } } },
+      ))).toStrictEqual([0, []]);
+    });
+
+    test('find items with complex and multiple filters', () => {
+      // Multiple filters
+      expect(finderExecutionTestValue(finder.execute(
+        { propString: { $eq: 'item_prime' }, propNumber: { $lte: 18 } },
+      ))).toStrictEqual([1, [0]]);
+      // Multiple operators
+      expect(finderExecutionTestValue(finder.execute(
+        { propNumber: { $lte: 25, $gte: 15, $ne: 19 } },
+      ))).toStrictEqual([3, [0, 2, 3]]);
+      // Multiple filters and Object search
+      expect(finderExecutionTestValue(finder.execute(
+        { propString: { $in: ['item_prime', 'item_third'] }, propArray: { $ne: undefined }, propMeta: { meta2: { $ne: undefined } } },
+      ))).toStrictEqual([1, [1]]);
+    });
+  });
+});

package/test/libs/player/DTPlayer.element.double.ts

@@ -0,0 +1,55 @@
+import {DTPlayer} from '../../../src';
+
+/******************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * *****/
+export const IDTest = 'DTPlayer-id-1234567';
+export const KeyTest = 'DTPlayer-key-1234567';
+
+// Specific elements constants
+export const KeyTest1 = 'DTPlayer-key-1234567-1';
+export const KeyTest2 = 'DTPlayer-key-1234567-2';
+
+/******************** 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 DTPlayerTest extends DTPlayer {
+  th_get_id(): string {
+    return this._id;
+  }
+
+  th_set_id(id: string): void {
+    this._id = id;
+  }
+
+  th_get_key(): string {
+    return this._key;
+  }
+
+  th_set_key(key: string): void {
+    this._key = key;
+  }
+
+  th_get_domain(): string {
+    return this._domain;
+  }
+}
+
+/** ****************** STUB CLASS
+ * Stub class, for using in other component
+ * **** */
+export class DTPlayerStub extends DTPlayerTest {
+  constructor(key: string) {
+    super(key);
+    this._key = key;
+    this._id = IDTest;
+  }
+
+  getId(): string {
+    return IDTest;
+  }
+}
+
+
+

package/test/libs/player/DTPlayer.element.spec.ts

@@ -0,0 +1,28 @@
+import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
+import {DTPlayerTest} from "./DTPlayer.element.double";
+import {DTElement, DTPlayer} from "../../../src";
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOToolsPlayerElement', () => {
+    let playerTest: DTPlayerTest;
+
+    beforeEach(() => {
+        playerTest = new DTPlayerTest();
+    });
+
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+
+    describe('inheritance', () => {
+        test('check good inheritance for class', () => {
+            expect(DTPlayer.prototype instanceof DTElement).toBeTruthy();
+        });
+    });
+
+    describe('_domain', () => {
+        test('domain must be "player"', () => {
+            expect(playerTest.th_get_domain()).toBe('player');
+        });
+    });
+});

package/test/libs/player/DTPlayer.manager.double.ts

@@ -0,0 +1,92 @@
+import {DTPlayer, DTPlayerManager} from '../../../src';
+import {DTAcceptedMetaData, DTManagerItemsType, DTManagerOptions} from "../../../src/types";
+import {DTBunchStubLibrary} from "../../core/DTBunch.double";
+import {DTPlayerStub} from "./DTPlayer.element.double";
+
+/******************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * *****/
+export const IDTest = 'DTPlayerManager-id-1234567';
+export const KeyTest = 'DTPlayerManager-key-1234567';
+
+/******************** 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 DTPlayerManagerTest extends DTPlayerManager {
+  th_get_id(): string {
+    return this._id;
+  }
+
+  th_set_id(id: string): void {
+    this._id = id;
+  }
+
+  th_get_key(): string {
+    return this._key;
+  }
+
+  th_set_key(key: string): void {
+    this._key = key;
+  }
+
+  th_get_domain(): string {
+    return this._domain;
+  }
+
+  th_get_items(): any {
+    return this._items;
+  }
+
+  th_set_items(items: DTManagerItemsType<DTPlayer<DTAcceptedMetaData>>): void {
+    this._items = items;
+  }
+
+  th_get_single_item(id: string): any {
+    return this._items[id];
+  }
+
+  th_get_scopes(): any {
+    return this._scopes;
+  }
+
+  th_set_scopes(scopes: any): void {
+    this._scopes = scopes;
+  }
+
+  th_get_library(): any {
+    return this._library;
+  }
+
+  th_set_library(library: any): void {
+    this._library = library;
+  }
+
+  th_get_options(): DTManagerOptions {
+    return this._options;
+  }
+}
+
+/** ****************** HELPER METHODS
+ * Additional helper methods to use with testing
+ * **** */
+export const populateManager = (manager: DTPlayerManagerTest): DTPlayerManagerTest => {
+  const mockedElements = [];
+
+  // Create players Stubs
+  let nbPlayers = 3;
+  while (nbPlayers > 0) {
+    const player = new DTPlayerStub(`player${nbPlayers}`);
+    mockedElements.push(player);
+
+    nbPlayers--;
+  }
+
+  // Library
+  manager.th_set_library(new DTBunchStubLibrary(mockedElements));
+
+  return manager;
+}
+
+
+

package/test/libs/player/DTPlayer.manager.spec.ts

@@ -0,0 +1,178 @@
+import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
+import {DTManager, DTPlayer, DTPlayerManager} from "../../../src";
+import {DTPlayerManagerTest} from "./DTPlayer.manager.double";
+import {DTPlayerStub, IDTest, KeyTest, KeyTest1, KeyTest2} from "./DTPlayer.element.double";
+import {managerDefaultOptions} from "../../../src/constants";
+
+/** ****************** MOCK DEPENDENCIES
+ * Dependencies used by the component are mocked with Jest
+ * **** */
+jest.mock('../../../src/libs/player/DTPlayer.element');
+jest.mock('../../../src/core/DTBunch');
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOToolsPlayerManager', () => {
+    let playerManagerTest: DTPlayerManagerTest;
+
+    beforeEach(() => {
+        playerManagerTest = new DTPlayerManagerTest();
+    });
+
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+
+    describe('inheritance', () => {
+        test('check good inheritance for class', () => {
+            expect(DTPlayerManager.prototype instanceof DTManager).toBeTruthy();
+        });
+    });
+
+    describe('_domain', () => {
+        test('domain must be "player"', () => {
+            expect(playerManagerTest.th_get_domain()).toBe('player');
+        });
+    });
+
+    describe('constructor()', () => {
+        beforeEach(() => {
+            (DTPlayer.prototype.getKey as any).mockImplementation(function() {
+                return this._key;
+            })
+        });
+
+        test('creation simple empty manager', () => {
+            const newPlayerManager = new DTPlayerManagerTest();
+
+            expect(newPlayerManager.th_get_key()).toBe('player');
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+            expect(newPlayerManager.th_get_scopes()).toStrictEqual(['default', 'virtual']);
+            expect(newPlayerManager.th_get_library()).toBeDefined();
+        });
+
+        test('creation with simple configuration - player number', () => {
+            const configuration = {
+                players: 3
+            }
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+
+            // Check creation of 3 DTPlayer
+            let calls = 3;
+            expect((DTPlayer.prototype.constructor as any).mock.calls.length).toBe(calls);
+            while (calls > 0) {
+                expect((DTPlayer.prototype.constructor as any).mock.calls[calls - 1][0]).toBe(`player${calls}`);
+                calls--;
+            }
+
+            // Check adding 3 DTPlayer to library
+            expect((newPlayerManager.th_get_library().add as any).mock.calls.length).toBe(3);
+        });
+
+        test('creation with simple configuration - player array', () => {
+            const configuration = {
+                players: [
+                    new DTPlayerStub(KeyTest),
+                    new DTPlayerStub(KeyTest1),
+                    new DTPlayerStub(KeyTest2),
+                ]
+            }
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls.length).toBe(1);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0].length).toBe(3);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0][0].th_get_key()).toBe(KeyTest);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0][1].th_get_key()).toBe(KeyTest1);
+            expect((newPlayerManager.th_get_library().addMany as any).mock.calls[0][0][2].th_get_key()).toBe(KeyTest2);
+        });
+
+        test('creation with simple configuration - invalid player number', () => {
+            const configuration = {
+                players: -3
+            }
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_items()).toStrictEqual({});
+
+            // No creation and adding
+            expect((DTPlayer.prototype.constructor as any).mock.calls.length).toBe(0);
+            expect((newPlayerManager.th_get_library().add as any).mock.calls.length).toBe(0);
+        });
+
+        test('creation with simple configuration - errors manager option', () => {
+            const configuration = {
+                errors: true
+            };
+            const newPlayerManager = new DTPlayerManagerTest(configuration);
+
+            expect(newPlayerManager.th_get_options()).toStrictEqual({
+                ...managerDefaultOptions,
+                errors: true
+            });
+        });
+    });
+
+    describe('getPlayer()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call get() of library', () => {
+            const library = playerManagerTest.th_get_library();
+
+            playerManagerTest.getPlayer(IDTest);
+
+            expect((library.get).mock.calls.length).toBe(1);
+            expect((library.get).mock.calls[0][0]).toBe(IDTest);
+        });
+    });
+
+    describe('addPlayer()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call add() of library', () => {
+            const library = playerManagerTest.th_get_library();
+            const playerToAdd = new DTPlayerStub(KeyTest);
+
+            playerManagerTest.addPlayer(playerToAdd);
+
+            expect((library.add).mock.calls.length).toBe(1);
+            expect((library.add).mock.calls[0][0]).toStrictEqual(playerToAdd);
+        });
+    });
+
+    describe('removePlayer()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call remove() of library', () => {
+            const library = playerManagerTest.th_get_library();
+
+            playerManagerTest.removePlayer(IDTest);
+
+            expect((library.remove).mock.calls.length).toBe(1);
+            expect((library.remove).mock.calls[0][0]).toBe(IDTest);
+        });
+    });
+
+    describe('findPlayers()', () => {
+        beforeEach(() => {
+            jest.spyOn(playerManagerTest, 'getLibrary').mockReturnValue(playerManagerTest.th_get_library());
+        });
+
+        test('alias - call find() of library', () => {
+            const library = playerManagerTest.th_get_library();
+            const testFilters = { id: { $eq: IDTest }, key: { $ne: KeyTest } };
+
+            playerManagerTest.findPlayers(testFilters);
+
+            expect((library.find).mock.calls.length).toBe(1);
+            expect((library.find).mock.calls[0][0]).toStrictEqual(testFilters);
+        });
+    });
+});

package/tsconfig.dev.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2015",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "test/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2015",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/dist/core/DTPlayer.d.ts

@@ -1,8 +0,0 @@
-import DYOToolsComponentWithMeta from './DTComponentWithMeta';
-import { DTAcceptedMetaData, DTPlayerToObject } from '../types';
-export default class DYOToolsPlayer<IComponentMeta extends DTAcceptedMetaData> extends DYOToolsComponentWithMeta<IComponentMeta> {
-    protected _componentType: string;
-    copy(): DYOToolsPlayer<IComponentMeta>;
-    toObject(): DTPlayerToObject<IComponentMeta>;
-    toString(): string;
-}

package/dist/core/DTPlayer.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const DTComponentWithMeta_1 = require("./DTComponentWithMeta");
-class DYOToolsPlayer extends DTComponentWithMeta_1.default {
-    constructor() {
-        super(...arguments);
-        this._componentType = 'player';
-    }
-    copy() {
-        const copyElement = new DYOToolsPlayer(this._key);
-        copyElement.setManyMeta(Object.assign({}, this.getManyMeta()));
-        return copyElement;
-    }
-    toObject() {
-        const objectPlayer = {
-            id: this._id,
-            key: this._key,
-            type: this._componentType,
-        };
-        if (this._meta && Object.keys(this._meta).length > 0) {
-            objectPlayer.meta = Object.assign({}, this.getManyMeta());
-        }
-        return objectPlayer;
-    }
-    toString() {
-        return `Component ${this._key} - Type: Player`;
-    }
-}
-exports.default = DYOToolsPlayer;
-//# sourceMappingURL=DTPlayer.js.map

package/dist/core/DTPlayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DTPlayer.js","sourceRoot":"","sources":["../../src/core/DTPlayer.ts"],"names":[],"mappings":";;AAAA,+DAA8D;AAG9D,MAAqB,cAA0D,SAAQ,6BAAyC;IAAhI;;QAIY,mBAAc,GAAG,QAAQ,CAAC;IAiDtC,CAAC;IAxCC,IAAI;QACF,MAAM,WAAW,GAAG,IAAI,cAAc,CAAiB,IAAI,CAAC,IAAI,CAAC,CAAC;QAClE,WAAW,CAAC,WAAW,mBAAM,IAAI,CAAC,WAAW,EAAE,EAAG,CAAC;QAEnD,OAAO,WAAW,CAAC;IACrB,CAAC;IAaD,QAAQ;QACN,MAAM,YAAY,GAAqC;YACrD,EAAE,EAAE,IAAI,CAAC,GAAG;YACZ,GAAG,EAAE,IAAI,CAAC,IAAI;YACd,IAAI,EAAE,IAAI,CAAC,cAAc;SAC1B,CAAC;QAEF,IAAI,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YACpD,YAAY,CAAC,IAAI,qBAAQ,IAAI,CAAC,WAAW,EAAE,CAAE,CAAC;SAC/C;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAOD,QAAQ;QACN,OAAO,aAAa,IAAI,CAAC,IAAI,iBAAiB,CAAC;IACjD,CAAC;CACF;AArDD,iCAqDC"}

package/dist/utils/filters.d.ts

@@ -1,6 +0,0 @@
-import { FilterOperatorType, StandardPrimitiveType } from '../types';
-export declare function validFiltersForItem(itemProp: StandardPrimitiveType, filter: StandardPrimitiveType, operator: FilterOperatorType.EQ): boolean;
-export declare function validFiltersForItem(itemProp: StandardPrimitiveType, filter: StandardPrimitiveType[], operator: FilterOperatorType.IN | FilterOperatorType.NIN): boolean;
-export declare function validFiltersForItem(itemProp: StandardPrimitiveType, filter: StandardPrimitiveType, operator: FilterOperatorType.NE): boolean;
-export declare function validFiltersForItem(itemProp: number, filter: number, operator: FilterOperatorType.LTE | FilterOperatorType.GTE): boolean;
-export declare function validFiltersForItem(itemProp: StandardPrimitiveType[], filter: StandardPrimitiveType, operator: FilterOperatorType.CONTAINS | FilterOperatorType.NCONTAINS): boolean;