@futdevpro/fsm-dynamo 1.9.6 → 1.9.8

package/src/{_utils → _collections/utils/math}/box-bounds.util.ts

@@ -28,6 +28,11 @@ export class DynamoFM_BoxBounds {
     return this._center;
   }
 
+  private _centerMargin: DynamoFM_Vector2;
+  get centerMargin(): DynamoFM_Vector2 {
+    return this._centerMargin;
+  }
+
   constructor(
     position: DynamoFM_Vector2 = new DynamoFM_Vector2(), 
     size: DynamoFM_Vector2 = new DynamoFM_Vector2()
@@ -66,7 +71,10 @@ export class DynamoFM_BoxBounds {
   }
 
   private calcCenter?(): void {
-    this._center = DynamoFM_Vector2.plus(this.pos, DynamoFM_Vector2.divide(this.size, 2));
+    const halfSize = DynamoFM_Vector2.divide(this.size, 2);
+
+    this._center = DynamoFM_Vector2.plus(this.pos, halfSize);
+    this._centerMargin = DynamoFM_Vector2.negative(halfSize);
   }
 
   clone?(): DynamoFM_BoxBounds {

package/src/_collections/utils/math/index.ts

@@ -0,0 +1,6 @@
+
+export * from './box-bounds.util';
+export * from './math.util';
+export * from './random.util';
+export * from './trigonometry.util';
+export * from './vector2.util';

package/src/{_utils → _collections/utils/math}/random.util.ts

@@ -1,5 +1,5 @@
 
-import { DynamoFM_RandomWeight } from '../_models/interfaces/random-weight.interface';
+import { DynamoFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
 
 export type DFM_Random = DynamoFM_Random;
 export class DynamoFM_Random {

package/src/_collections/utils/pipe-transforms/country-pipe.util.ts

@@ -0,0 +1,18 @@
+
+
+
+
+
+
+
+import { DynamoFM_CountryISO } from '../../../_models';
+import { DynamoFM_countryISOs } from '../../constants/courtry-isos.const';
+
+
+export function DynamoFM_country_pipeTransform(countryISO: string): string {
+  const result = DynamoFM_countryISOs.find(
+    (iso: DynamoFM_CountryISO): boolean => iso.iso2 === countryISO
+  )?.name;
+
+  return result ?? countryISO;
+}

package/src/_collections/utils/pipe-transforms/custom-pipe.util.ts

@@ -0,0 +1,9 @@
+
+
+
+
+
+
+export function DynamoFM_custom_pipeTransform<T, K>(value: T, customTransform: (input: T) => K): K {
+  return customTransform(value);
+}

package/src/_collections/utils/pipe-transforms/division-pipe.util.ts

@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
+import { DynamoFM_CountryDivision } from '../../../_models';
+import { DynamoFM_countryDivisions } from '../../constants/country-divisions.const';
+
+if (!DynamoFM_countryDivisions) throw new Error('Cannot find country divisions JSON file.');
+
+export function DynamoFM_division_pipeTransform(divisionCode: string, countryISO: string): string {
+  const result: string = DynamoFM_countryDivisions?.find(
+    (d: DynamoFM_CountryDivision): boolean => d.code === divisionCode && d.iso === countryISO
+  )?.name;
+
+  return result ?? divisionCode;
+}

package/src/_collections/utils/pipe-transforms/index.ts

@@ -0,0 +1,16 @@
+
+
+
+
+export * from './country-pipe.util';
+export * from './custom-pipe.util';
+export * from './division-pipe.util';
+export * from './list-pipe.util';
+export * from './multi-pipe-pipe.util';
+export * from './obj-key-pipe.util';
+export * from './obj-key-pipe.util';
+export * from './range-pipe.util';
+export * from './region-pipe.util';
+export * from './replace-pipe.util';
+export * from './slider-pipe.util';
+export * from './smart-replace-pipe.util';

package/src/_collections/utils/pipe-transforms/list-pipe.util.ts

@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+import { DynamoFM_CountryISO } from '../../../_models';
+import { DynamoFM_countryISOs } from '../../constants/courtry-isos.const';
+
+
+export function DynamoFM_list_pipeTransform(value: any[]): string {
+  return value.toString().replace(/,/g, ', ');  
+}

package/src/_collections/utils/pipe-transforms/multi-pipe-pipe.util.ts

@@ -0,0 +1,161 @@
+
+
+
+
+
+
+
+import { DynamoFM_AngularMultiPipeAvailable, DynamoFM_MultiPipeAvailable, DynamoFM_Pipe, DynamoFM_allDynamoPipes, DynamoFM_allMultiPipesAvailable } from '../../../_enums';
+import { DynamoFM_RangeValue } from '../../../_models';
+import { DynamoFM_MultiPipe_Setting } from '../../../_models/interfaces/multi-pipe-settings.type';
+import { DynamoFM_pipeTransforms } from '../../constants';
+
+
+export type DynamoFM_MultiPipeAngularPipes = {
+  [pipeName in DynamoFM_AngularMultiPipeAvailable]: (value: string, ...args: unknown[]) => string;
+};
+
+export const DynamoFM_multiPipeAngularPipes: DynamoFM_MultiPipeAngularPipes = {
+  [DynamoFM_AngularMultiPipeAvailable.currency]: null,
+  [DynamoFM_AngularMultiPipeAvailable.date]: null,
+  [DynamoFM_AngularMultiPipeAvailable.decimal]: null,
+  [DynamoFM_AngularMultiPipeAvailable.number]: null,
+  [DynamoFM_AngularMultiPipeAvailable.percent]: null,
+};
+
+export function DynamoFM_multiPipe_pipeTransform(
+  value: unknown, pipes: DynamoFM_MultiPipe_Setting[]
+): string | number | DynamoFM_RangeValue | any {
+  /* console.log(
+    'applyPipes...',
+    '\nvalue:', value,
+    '\npipes:', DynamoFM_clone(pipes)
+  ); */
+
+  stackPipes(pipes);
+
+  /* console.log('stacked pipes:', DynamoFM_clone(pipes)); */
+
+  for (let i = 0; i < pipes.length; i++) {
+    const pipe: DynamoFM_MultiPipe_Setting = pipes[i];
+    /* pipes.forEach((pipe: DynamoFM_MultiPipe_Setting): void => { */
+    const keys: string[] = Object.keys(pipe);
+
+    if (keys.length !== 1) {
+      console.warn(
+        'DYNAMO WARNING: ' +
+        '\nMultiPipe: pipeSettings has more than one key...',
+        '\npipeSettings: ', pipe,
+        '\n\n',
+        new Error()
+      );
+
+      return value;
+    }
+
+    const pipeName: DynamoFM_MultiPipeAvailable = keys[0] as DynamoFM_MultiPipeAvailable;
+
+    if (!DynamoFM_allMultiPipesAvailable.includes(pipeName as DynamoFM_MultiPipeAvailable)) {
+      console.warn(
+        'DYNAMO WARNING: ' +
+        '\nMultiPipe: unknown pipe "' + pipeName + '"...',
+        '\nsorry, but this pipe is not supported by the MultiPipe yet.',
+        '\navailable pipes are: ' + DynamoFM_allMultiPipesAvailable.join(', '),
+        '\nthe custom pipe is basically usable for anything, you might try to use that.',
+        '\n\n',
+        new Error()
+      );
+
+      return value;
+    }
+
+    const pipeArgs: any[] = pipe[pipeName];
+
+    /* console.log(
+      'transforming...',
+      '\npipe:', pipeName,
+      '\nargs:', pipeArgs,
+      '\nvalue:', value
+    ); */
+
+    if (DynamoFM_allDynamoPipes.includes(pipeName as DynamoFM_Pipe)) {
+      if (pipeArgs?.length) {
+        value = DynamoFM_pipeTransforms[pipeName](value, ...pipeArgs);
+      } else {
+        value = DynamoFM_pipeTransforms[pipeName](value);
+      }      
+    } else {
+      if (!DynamoFM_multiPipeAngularPipes[pipeName]) {
+        console.error(
+          'DYNAMO ERROR: ' +
+          '\nMultiPipe: Angular pipe "' + pipeName + '" is not defined...',
+          '\nPlease set the pipe in the DynamoFM_multiPipeAngularPipes object.',
+          '\n\n',
+          new Error()
+        );
+
+        return value;
+      }
+      
+      value = DynamoFM_multiPipeAngularPipes[pipeName](value, ...pipeArgs);
+    }
+  }
+
+  return value;
+}
+
+/**
+ * This method stacks the pipes in the pipe settings.
+ * Developing this funcfion you must know which pipe have multiPipe settings
+ * and which argument is that
+ *
+ * IMPORTANT: the args are starting from the second transform argument!
+ *
+ * @param pipes
+ */
+function stackPipes(pipes: DynamoFM_MultiPipe_Setting[]): void {
+  for (let i = 0; i < pipes.length; i++) {
+    if (i + 1 < pipes.length) {
+      const pipe: DynamoFM_MultiPipe_Setting = pipes[i];
+      const pipeName: DynamoFM_MultiPipeAvailable =
+        Object.keys(pipe)[0] as DynamoFM_MultiPipeAvailable;
+
+      switch (pipeName) {
+        case DynamoFM_Pipe.range:
+          const furtherPipesAfterRange: DynamoFM_MultiPipe_Setting[] = pipes.splice(i + 1);
+
+          if (!(pipe[pipeName] as any[])?.length) {
+            (pipe[pipeName] as any[]) = [ null, furtherPipesAfterRange ];
+          } else if ((pipe[pipeName][1] as any[])?.length) {
+            (pipe[pipeName][1] as any[]).push(...furtherPipesAfterRange);
+          } else {
+            (pipe[pipeName][1] as DynamoFM_MultiPipe_Setting[]) = furtherPipesAfterRange;
+          }
+          break;
+
+        case DynamoFM_Pipe.smartReplace:
+          const furtherPipesAfterSR: DynamoFM_MultiPipe_Setting[] = pipes.splice(i + 1);
+
+          if (!(pipe[pipeName] as any[])?.length) {
+            throw new Error(
+              'DYNAMO ERROR: ' +
+              '\nMultiPipe: SmartReplacePipe has no arguments...' +
+              '\nSmartReplacePipe needs at least one argument: replaceTo.' +
+              '\nMaybe you forgot to put the replacerObject in an array?' +
+              '\n\n'
+            );
+          }
+
+          if ((pipe[pipeName][1] as any[])?.length) {
+            (pipe[pipeName][1] as any[]).push(...furtherPipesAfterSR);
+          } else {
+            (pipe[pipeName][1] as DynamoFM_MultiPipe_Setting[]) = furtherPipesAfterSR;
+          }
+          break;
+
+        default:
+          break;
+      }
+    }
+  }
+}

package/src/_collections/utils/pipe-transforms/obj-key-pipe.util.ts

@@ -0,0 +1,9 @@
+
+
+
+
+
+
+export function DynamoFM_objKey_pipeTransform<Obj_T>(value: Obj_T): string[] {
+  return value ? Object.keys(value) : [];
+}

package/src/_collections/utils/pipe-transforms/range-pipe.util.ts

@@ -0,0 +1,94 @@
+
+
+
+
+
+
+
+import { DynamoFM_RangePipeSetting } from '../../../_enums';
+import { DynamoFM_RangeValue } from '../../../_models';
+import { DynamoFM_MultiPipe_Setting } from '../../../_models/interfaces/multi-pipe-settings.type';
+import { DynamoFM_multiPipe_pipeTransform } from './multi-pipe-pipe.util';
+
+export function DynamoFM_range_pipeTransform(
+  value: DynamoFM_RangeValue,
+  setting: DynamoFM_RangePipeSetting,
+  multiPipes?: DynamoFM_MultiPipe_Setting[]
+): string | number | DynamoFM_RangeValue {
+  if (!checkRangePipeRequirements(value, setting, multiPipes)) {
+    return value;
+  }
+
+  switch (setting) {
+    case DynamoFM_RangePipeSetting.avg:
+    case DynamoFM_RangePipeSetting.average:
+      return (value.to + value.from) / 2;
+
+    case DynamoFM_RangePipeSetting.min:
+    case DynamoFM_RangePipeSetting.from:
+      return value.from;
+
+    case DynamoFM_RangePipeSetting.max:
+    case DynamoFM_RangePipeSetting.to:
+      return value.to;
+
+    case DynamoFM_RangePipeSetting.both:
+    case DynamoFM_RangePipeSetting.fromTo:
+      if (0 < multiPipes?.length) {
+        if (value.from === value.to) {
+          return DynamoFM_multiPipe_pipeTransform(value.from, multiPipes);
+        } else {
+          return DynamoFM_multiPipe_pipeTransform(value.from, multiPipes) +
+            ' - ' +
+            DynamoFM_multiPipe_pipeTransform(value.to, multiPipes);
+        }
+      } else {
+        return `${value.from} - ${value.to}`;
+      }
+
+    default:
+      return value;
+  }
+}
+
+function checkRangePipeRequirements(
+  value: DynamoFM_RangeValue,
+  setting: DynamoFM_RangePipeSetting | string,
+  multiPipes?: DynamoFM_MultiPipe_Setting[]
+): boolean {
+  if (!value?.isRange) {
+    console.warn(
+      'DYNAMO WARNING: ' +
+      '\nRangePipe: value is not a DynamoFM_RangeValue...',
+      '\nrange pipe is only usable for DynamoFM_RangeValue.',
+      '\nvalue: ', value,
+      '\n\n',
+      new Error()
+    );
+
+    return false;
+  }
+
+  if (!setting) {
+    setting = DynamoFM_RangePipeSetting.fromTo;
+  }
+
+  if (
+    setting !== DynamoFM_RangePipeSetting.both &&
+    setting !== DynamoFM_RangePipeSetting.fromTo &&
+    0 < multiPipes?.length
+  ) {
+    console.warn(
+      'DYNAMO WARNING: ' +
+      '\nRangePipe: you can only use further pipes with setting "both"/"from-to"...',
+      '\nThere is no need to use this special syntax for the other pipes.',
+      '\nvalue: ', value,
+      '\nsetting: ', setting,
+      '\nfurtherPipes: ', multiPipes,
+      '\n\n',
+      new Error()
+    );
+  }
+
+  return true;
+}

package/src/_collections/utils/pipe-transforms/region-pipe.util.ts

@@ -0,0 +1,18 @@
+
+
+
+
+
+
+
+import { DynamoFM_CountryISO } from '../../../_models';
+import { DynamoFM_countryISOs } from '../../constants/courtry-isos.const';
+
+
+export function DynamoFM_region_pipeTransform(countryISO: string): string {
+  const result = DynamoFM_countryISOs.find(
+    (iso: DynamoFM_CountryISO): boolean => iso.iso2 === countryISO
+  )?.region;
+
+  return result ?? countryISO;
+}

package/src/_collections/utils/pipe-transforms/replace-pipe.util.ts

@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+export function DynamoFM_replace_pipeTransform(value: string, from: string, to: string): string {
+  return value?.replaceAll(from, to) ?? value;
+}

package/src/_collections/utils/pipe-transforms/slider-pipe.util.ts

@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+import { DynamoFM_RangeValue } from '../../../_models';
+
+export function DynamoFM_slider_pipeTransform(
+  value: number | DynamoFM_RangeValue<number> | string,
+): string {
+  if (value instanceof DynamoFM_RangeValue /* (value as DynamoFM_RangeValue).isRange */) {
+    return value.toString();
+  } else if (typeof value === 'number') {
+    return `${value}`;
+  } else {
+    return value;
+  }
+}

package/src/_collections/utils/pipe-transforms/smart-replace-pipe.util.ts

@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+import { DynamoFM_MultiPipe_Setting } from '../../../_models/interfaces/multi-pipe-settings.type';
+import { DynamoFM_multiPipe_pipeTransform } from './multi-pipe-pipe.util';
+
+
+/**
+ * Replaces the keys from the replacer with the values from the replacer object.
+ */
+export function DynamoFM_smartReplace_pipeTransform(
+  value: string, replacer: object, multiPipes?: DynamoFM_MultiPipe_Setting[]
+): string {
+
+  if (!replacer) {
+    console.warn(
+      'DYNAMO WARNING: ' +
+      '\nSmartReplacePipe: replaceTo is not defined...',
+      '\n\n',
+      new Error()
+    );
+
+    return value;
+  }
+
+  for (const key in replacer) {
+    if (replacer[key]?.value) {
+      if (!replacer[key]?.pipes) {
+        console.warn(
+          'DYNAMO WARNING: ' +
+          '\nSmartReplacePipe: replaceTo[' + key + '].multiPipe is not defined...',
+          '\n\n',
+          new Error()
+        );
+
+        return;
+      }
+
+      if (!Array.isArray(replacer[key].pipes)) {
+        console.warn(
+          'DYNAMO WARNING: ' +
+          '\nSmartReplacePipe: replaceTo[' + key + '].multiPipe is not an array...',
+          '\n\n',
+          new Error()
+        );
+
+        return;
+      }
+
+      replacer[key] = DynamoFM_multiPipe_pipeTransform(
+        replacer[key].value,
+        replacer[key].pipes
+      );
+    }
+
+    if (multiPipes?.length) {
+      replacer[key] = DynamoFM_multiPipe_pipeTransform(
+        replacer[key],
+        multiPipes
+      );
+    }
+
+    value = value.replaceAll(`{${key}}`, replacer[key]);
+  }
+
+  return value;
+}

package/src/_collections/utils/regex/index.ts

@@ -0,0 +1,5 @@
+
+
+export * from './password-regex.util';
+export * from './regex.util';
+export * from './username-regex.util';

package/src/{_utils → _collections/utils}/regions.util.ts

@@ -1,16 +1,16 @@
 
-import * as ISOs from '../_constants/location/country-codes-ISO-3166.json';
+import * as ISOs from '../assets/location/country-codes-ISO-3166.json';
 
-import * as PhoneCodes from '../_constants/location/country-phone-codes.json';
-import * as Divisions from '../_constants/location/country-divisions-ISO-3166-all-list.json';
+import * as PhoneCodes from '../assets/location/country-phone-codes.json';
+import * as Divisions from '../assets/location/country-divisions-ISO-3166-all-list.json';
 
-import { DynamoFM_Region } from '../_enums/region.enum';
-import { DynamoFM_Error } from '../_models';
+import { DynamoFM_Region } from '../../_enums/location/region.enum';
+import { DynamoFM_Error } from '../../_models';
 import { 
   DynamoFM_CountryPhoneCode 
-} from '../_models/interfaces/location/country-phone-code.interface';
-import { DynamoFM_CountryISO } from '../_models/interfaces/location/country-iso.interface';
-import { DynamoFM_CountryDivision } from '../_models/interfaces/location/country-division.interface';
+} from '../../_models/interfaces/location/country-phone-code.interface';
+import { DynamoFM_CountryISO } from '../../_models/interfaces/location/country-iso.interface';
+import { DynamoFM_CountryDivision } from '../../_models/interfaces/location/country-division.interface';
 
 import { DynamoFM_JSONListify } from './utilities.util';
 
@@ -19,12 +19,16 @@ export class DynamoFM_Regions {
   /* static divisions: DivisionCollection = DynamoFM_Regions.getSubdivisionCollection(); */
   static divisions: DynamoFM_CountryDivision[] = DynamoFM_Regions.getAllDivisions();
   static phoneCodes: DynamoFM_CountryPhoneCode[] = DynamoFM_Regions.getAllPhoneCodes();
-  static ISOs: DynamoFM_CountryISO[] = DynamoFM_Regions.getAllCountryISO();
+  static countryISOs: DynamoFM_CountryISO[] = DynamoFM_Regions.getAllCountryISO();
 
   private static getAllDivisions(): DynamoFM_CountryDivision[] {
+    if (!Divisions) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
+
     return DynamoFM_JSONListify(Divisions);
   }
   private static getAllPhoneCodes(): DynamoFM_CountryPhoneCode[] {
+    if (!PhoneCodes) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
+    
     return DynamoFM_JSONListify(PhoneCodes);
   }
 
@@ -32,6 +36,8 @@ export class DynamoFM_Regions {
     return Divisions as DivisionCollection;
   } */
   private static getAllCountryISO(): DynamoFM_CountryISO[] {
+    if (!ISOs) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
+
     const result: DynamoFM_CountryISO[] = DynamoFM_JSONListify(ISOs);
 
     result.forEach((iso: DynamoFM_CountryISO): void => {
@@ -47,13 +53,13 @@ export class DynamoFM_Regions {
   }
 
   static isoToCountryIso(iso2: string): DynamoFM_CountryISO {
-    const country: DynamoFM_CountryISO = this.ISOs.find(
+    const country: DynamoFM_CountryISO = this.countryISOs.find(
       (iso: DynamoFM_CountryISO): boolean => iso.iso2 == iso2
     );
 
     if (!country) {
       throw new DynamoFM_Error({ 
-        message: `Cannot find ISO-3166 code for this: ${iso2}` 
+        message: `Cannot find ISO-3166 code for this: ${iso2}`,
       });
     } else {
       return country;
@@ -61,13 +67,13 @@ export class DynamoFM_Regions {
   }
 
   static isoToRegion(iso2: string): DynamoFM_Region {
-    const region: DynamoFM_Region = this.ISOs.find(
+    const region: DynamoFM_Region = this.countryISOs.find(
       (iso: DynamoFM_CountryISO): boolean => iso.iso2 == iso2
     )?.region;
 
     if (!region) {
       throw new DynamoFM_Error({ 
-        message: `Cannot find ISO-3166 code for this: ${iso2}` 
+        message: `Cannot find ISO-3166 code for this: ${iso2}`,
       });
     } else {
       return region;
@@ -81,7 +87,7 @@ export class DynamoFM_Regions {
 
     if (!phoneCode) {
       throw new DynamoFM_Error({ 
-        message: `Cannot find ISO-3166 code for this: ${iso2}` 
+        message: `Cannot find ISO-3166 code for this: ${iso2}`,
       });
     } else {
       return phoneCode;

package/src/_collections/utils/time.util.spec.ts

@@ -0,0 +1,50 @@
+
+import { DynamoFM_LogStyle } from '../../_enums';
+import { DynamoFM_Log } from './log.util';
+import { DynamoFM_Time } from './time.util';
+
+describe('DynamoFM_Time', () => {
+  xit(DynamoFM_Log.addStyle('tenYearsAgo', [DynamoFM_LogStyle.yellow]) +' should return correct date', () => {
+    const date = DynamoFM_Time.tenYearsAgo(new Date('2021-01-01'));
+    const expected = new Date('2011-01-01');
+
+    expect(date).toEqual(expected);
+  });
+  
+  xit(DynamoFM_Log.addStyle('oneYearAgo', [DynamoFM_LogStyle.yellow]) +' should return correct date', () => {
+    const date = DynamoFM_Time.oneYearAgo(new Date('2021-01-01'));
+    const expected = new Date('2020-01-01');
+
+    expect(date).toEqual(expected);
+  });
+
+  xit(DynamoFM_Log.addStyle('oneMonthAgo', [DynamoFM_LogStyle.yellow]) +' should return correct date', () => {
+    const date = DynamoFM_Time.oneMonthAgo(new Date('2021-01-01'));
+    const expected = new Date('2020-12-01');
+
+    expect(date).toEqual(expected);
+  });
+
+  it(DynamoFM_Log.addStyle('oneWeekAgo', [DynamoFM_LogStyle.yellow]) +' should return correct date', () => {
+    const date = DynamoFM_Time.oneWeekAgo(new Date('2021-01-01'));
+    const expected = new Date('2020-12-25');
+
+    expect(date).toEqual(expected);
+  });
+
+  it(DynamoFM_Log.addStyle('oneDayAgo', [DynamoFM_LogStyle.yellow]) +' should return correct date', () => {
+    const date = DynamoFM_Time.oneDayAgo(new Date('2021-01-01'));
+    const expected = new Date('2020-12-31');
+
+    expect(date).toEqual(expected);
+  });
+
+  it(DynamoFM_Log.addStyle('oneHourAgo', [DynamoFM_LogStyle.yellow]) +' should return correct date', () => {
+    const date = DynamoFM_Time.oneHourAgo(new Date('2021-01-01T00:00:00'));
+    const expected = new Date('2020-12-31T23:00:00');
+
+    expect(date).toEqual(expected);
+  });
+
+
+});