dyo-tools 0.3.0 → 0.4.0

package/src/types/core.ts

@@ -1,169 +1,204 @@
-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>,
-}
+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/player.ts

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

package/test/core/DTAction.double.ts

@@ -17,38 +17,22 @@ export const action1ToObject: DTComponentToObject = {
   type: 'action'
 }
 
-/******************** STUB ABSTRACT IMPLEMENTATION
- * Implementation of abstract component class for tests
- * *****/
-export class DTActionImpl extends DTAction<string> {
-  async execute(payload: string): Promise<void> {
-    throw `${this._key} : ${payload}`;
-  }
-}
-
 /** ****************** 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 DTActionImpl {
-  th_get_id(): string {
-    return this._id;
-  }
+export class DTActionTest extends DTAction<string> {
 
-  th_set_id(id: string): void {
+  constructor(
+    id: string = IDTest,
+    key: string = KeyTest,
+  ) {
+    super(key);
     this._id = id;
   }
 
-  th_get_key(): string {
-    return this._key;
-  }
-
-  th_set_key(key: string): void {
-    this._key = key;
-  }
-
-  th_get_componentType(): string {
-    return this._componentType;
+  async execute(payload: string): Promise<void> {
+    throw `${this._key} : ${payload}`;
   }
 }
 
@@ -64,12 +48,12 @@ export class DTActionStub extends DTActionTest {
     this._errors = [];
   }
 
-  getId(): string {
-    return IDTest;
+  _setId(id: string) {
+    this._id = id;
   }
 
-  getKey(): string {
-    return KeyTest;
+  _setKey(key: string) {
+    this._key = key;
   }
 }
 

package/test/core/DTAction.spec.ts

@@ -1,24 +1,14 @@
-import {DTComponent, DTAction} from "../../src";
-import {mockOverriddenMethods} from "./DTComponent.double";
+import {DTAction, DTComponent} from "../../src";
 import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
 import {DTActionTest, IDTest, KeyTest} from "./DTAction.double";
 
-/** ****************** MOCK DEPENDENCIES
- * Dependencies used by the component are mocked with Jest
- * **** */
-jest.mock('../../src/core/DTComponent');
-jest.mock('../../src/core/DTError');
-// Add specific mock for inherited methods to have a basic implementation
-mockOverriddenMethods(DTComponent);
-
 /** *********************** TESTS SUITES ****************************** */
-describe('class DYOToolsAction', () => {
+describe('class DTAction' +
+  '', () => {
   let actionTest: DTActionTest;
 
   beforeEach(() => {
     actionTest = new DTActionTest();
-    actionTest.th_set_id(IDTest);
-    actionTest.th_set_key(KeyTest);
   });
 
   afterEach(() => {
@@ -33,16 +23,18 @@ describe('class DYOToolsAction', () => {
 
   describe('_componentType', () => {
     test('componentType must be "action"', () => {
-      expect(actionTest.th_get_componentType()).toBe('action');
+      expect(actionTest.getComponentType()).toBe('action');
     });
   });
 
   describe('getMaster', () => {
     test('call get context with master accessor', () => {
+      const getContextSpy = jest.spyOn(actionTest, 'getContext');
+      
       actionTest.getMaster();
 
-      expect((actionTest.getContext as any).mock.calls.length).toBe(1);
-      expect((actionTest.getContext as any).mock.calls[0][0]).toBe('master');
+      expect(getContextSpy.mock.calls.length).toBe(1);
+      expect(getContextSpy.mock.calls[0][0]).toBe('master');
     });
   });