@futdevpro/fsm-dynamo 1.20.9 → 1.20.12

package/src/_modules/pipe/_collections/utils/pip-country-pipe.util.spec.ts

@@ -1,47 +0,0 @@
-
-import { DyFM_country_pipeTransform } from './pip-country-pipe.util';
-import { DyFM_countryISOs } from '../../../location/_collections/loc-country-isos.const';
-import { DyFM_CountryISO } from '../../../location/_models/loc-country-iso.interface';
-
-describe('| DyFM_country_pipeTransform', () => {
-  it('| should return the country name when a valid ISO code is provided', () => {
-    const validISO: string = DyFM_countryISOs[0].iso2;
-    const expectedName: string = DyFM_countryISOs[0].name;
-
-    const result: string = DyFM_country_pipeTransform(validISO);
-
-    expect(result).toBe(expectedName);
-  });
-
-  it('| should return the input ISO code when an invalid ISO code is provided', () => {
-    const invalidISO: string = 'ZZ';
-
-    const result: string = DyFM_country_pipeTransform(invalidISO);
-
-    expect(result).toBe(invalidISO);
-  });
-
-  it('| should return the input ISO code when an empty string is provided', () => {
-    const emptyISO: string = '';
-
-    const result: string = DyFM_country_pipeTransform(emptyISO);
-
-    expect(result).toBe(emptyISO);
-  });
-
-  it('| should return the input ISO code when a null value is provided', () => {
-    const nullISO: string = null as unknown as string;
-
-    const result: string = DyFM_country_pipeTransform(nullISO);
-
-    expect(result).toBe(nullISO);
-  });
-
-  it('| should return the input ISO code when an undefined value is provided', () => {
-    const undefinedISO: string = undefined as unknown as string;
-
-    const result: string = DyFM_country_pipeTransform(undefinedISO);
-
-    expect(result).toBe(undefinedISO);
-  });
-});

package/src/_modules/pipe/_collections/utils/pip-country-pipe.util.ts

@@ -1,41 +0,0 @@
-
-
-
-
-
-
-
-import { DyFM_CountryISO } from '../../../location/_models/loc-country-iso.interface';
-import { DyFM_countryISOs } from '../../../location/_collections/loc-country-isos.const';
-
-/**
- * 
- * @param countryISO - country ISO code
- * @returns country name
- * 
- * @example
- * 
- * ```html
- * {{ 'US' | country }} 
- * ```
- * will return `United States`
- *   
- *   
- * ```html
- * {{ 'DE' | country }}
- * ```
- * will return `Germany`
- *   
- *   
- * ```html
- * {{ 'ZZ' | country }}
- * ```
- * will return `ZZ`
- */
-export function DyFM_country_pipeTransform(countryISO: string): string {
-  const result = DyFM_countryISOs.find(
-    (iso: DyFM_CountryISO): boolean => iso.iso2 === countryISO
-  )?.name;
-
-  return result ?? countryISO;
-}

package/src/_modules/pipe/_collections/utils/pip-custom-pipe.util.spec.ts

@@ -1,39 +0,0 @@
-
-import { DyFM_custom_pipeTransform } from './pip-custom-pipe.util';
-
-describe('| DyFM_custom_pipeTransform', () => {
-  it('| should apply the custom transform function to the input value', () => {
-    const input = 5;
-    const transformFunction = (x: number) => x * 2;
-    const result = DyFM_custom_pipeTransform(input, transformFunction);
-    expect(result).toBe(10);
-  });
-
-  it('| should handle string transformations correctly', () => {
-    const input = 'hello';
-    const transformFunction = (x: string) => x.toUpperCase();
-    const result = DyFM_custom_pipeTransform(input, transformFunction);
-    expect(result).toBe('HELLO');
-  });
-
-  it('| should handle object transformations correctly', () => {
-    const input = { name: 'Alice', age: 30 };
-    const transformFunction = (x: { name: string; age: number }) => ({ ...x, age: x.age + 1 });
-    const result = DyFM_custom_pipeTransform(input, transformFunction);
-    expect(result).toEqual({ name: 'Alice', age: 31 });
-  });
-
-  it('| should handle array transformations correctly', () => {
-    const input = [1, 2, 3];
-    const transformFunction = (x: number[]) => x.map(num => num * 2);
-    const result = DyFM_custom_pipeTransform(input, transformFunction);
-    expect(result).toEqual([2, 4, 6]);
-  });
-
-  it('| should return undefined if the transform function returns undefined', () => {
-    const input = 'test';
-    const transformFunction = (x: string) => undefined;
-    const result = DyFM_custom_pipeTransform(input, transformFunction);
-    expect(result).toBeUndefined();
-  });
-});

package/src/_modules/pipe/_collections/utils/pip-custom-pipe.util.ts

@@ -1,30 +0,0 @@
-
-
-
-
-
-/**
- * This is a helper function to create custom pipes
- * you can use it to create custom pipes within the same component
- * 
- * @example
- * 
- * ```html
- * {{ 'Hello' | custom: (value) => value.toUpperCase() }}
- * ```
- * will return `HELLO`
- * 
- * 
- * ```html
- * {{ 'Hello' | custom: (value, ...args) => value.toUpperCase() }}
- * ```
- * will return `HELLO`
- * 
- * 
- */
-export function DyFM_custom_pipeTransform<T, K>(
-  value: T, 
-  customTransform: (input: T, ...args: any[]
-) => K, ...args: any[]): K {
-  return customTransform(value, ...args);
-}

package/src/_modules/pipe/_collections/utils/pip-division-pipe.util.spec.ts

@@ -1,41 +0,0 @@
-
-import { DyFM_division_pipeTransform } from './pip-division-pipe.util';
-import { DyFM_CountryDivision } from '../../../location/_models/loc-country-division.interface';
-import { DyFM_countryDivisions } from '../../../location/_collections/loc-country-divisions.const';
-
-describe('| DyFM_division_pipeTransform', () => {
-  const mockCountryDivisions: DyFM_CountryDivision[] = [
-    { code: 'CA', iso: 'US', name: 'California' },
-    { code: 'TX', iso: 'US', name: 'Texas' },
-    { code: 'ON', iso: 'CA', name: 'Ontario' }
-  ];
-
-  beforeEach(() => {
-    (DyFM_countryDivisions as DyFM_CountryDivision[]) = mockCountryDivisions;
-  });
-
-  it('| should return the name of the division when a matching division code and country ISO are found', () => {
-    const result = DyFM_division_pipeTransform('CA', 'US');
-    expect(result).toBe('California');
-  });
-
-  it('| should return the division code when no matching division is found', () => {
-    const result = DyFM_division_pipeTransform('NY', 'US');
-    expect(result).toBe('NY');
-  });
-
-  it('| should return the division code when the country ISO does not match', () => {
-    const result = DyFM_division_pipeTransform('CA', 'CA');
-    expect(result).toBe('CA');
-  });
-
-  it('| should return the division code when the division code is not found', () => {
-    const result = DyFM_division_pipeTransform('BC', 'CA');
-    expect(result).toBe('BC');
-  });
-
-  it('| should handle empty division code and country ISO gracefully', () => {
-    const result = DyFM_division_pipeTransform('', '');
-    expect(result).toBe('');
-  });
-});

package/src/_modules/pipe/_collections/utils/pip-division-pipe.util.ts

@@ -1,36 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-import { DyFM_CountryDivision } from '../../../location/_models/loc-country-division.interface';
-import { DyFM_countryDivisions } from '../../../location/_collections/loc-country-divisions.const';
-
-/**
- * This pipe will return the division name for a given division code and country ISO
- * 
- * @example
- * 
- * ```html
- * {{ 'US-CA' | division: 'US' }}
- * ```
- * will return `California`
- * 
- * ```html
- * {{ 'DE-BE' | division: 'DE' }}
- * ```
- * will return `Berlin`
- * 
- */
-export function DyFM_division_pipeTransform(divisionCode: string, countryISO: string): string {
-  const result: string = DyFM_countryDivisions?.find(
-    (d: DyFM_CountryDivision): boolean => d?.code === divisionCode && d?.iso === countryISO
-  )?.name;
-
-  return result ?? divisionCode;
-}

package/src/_modules/pipe/_collections/utils/pip-json-pipe.util.spec.ts

@@ -1,62 +0,0 @@
-import { DyFM_json_pipeTransform } from './pip-json-pipe.util';
-
-describe('| DyFM_json_pipeTransform', (): void => {
-  it('| should stringify an object with default depth', (): void => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = DyFM_json_pipeTransform(obj);
-
-    expect(result).toBe(JSON.stringify(obj, null, 2));
-  });
-
-  it('| should stringify an object with custom depth', (): void => {
-    const obj = { a: 1, b: 2, c: 3 };
-    const result = DyFM_json_pipeTransform(obj, 4);
-
-    expect(result).toBe(JSON.stringify(obj, null, 4));
-  });
-
-  it('| should handle arrays', (): void => {
-    const arr = [1, 2, 3];
-    const result = DyFM_json_pipeTransform(arr);
-
-    expect(result).toBe(JSON.stringify(arr, null, 2));
-  });
-
-  it('| should handle nested objects', (): void => {
-    const obj = { a: { b: { c: 1 } } };
-    const result = DyFM_json_pipeTransform(obj);
-
-    expect(result).toBe(JSON.stringify(obj, null, 2));
-  });
-
-  it('| should handle null', (): void => {
-    const result = DyFM_json_pipeTransform(null);
-
-    expect(result).toBe(JSON.stringify(null, null, 2));
-  });
-
-  it('| should handle undefined', (): void => {
-    const result = DyFM_json_pipeTransform(undefined);
-
-    expect(result).toBe(JSON.stringify(undefined, null, 2));
-  });
-
-  it('| should handle strings', (): void => {
-    const result = DyFM_json_pipeTransform('test');
-
-    expect(result).toBe(JSON.stringify('test', null, 2));
-  });
-
-  it('| should handle numbers', (): void => {
-    const result = DyFM_json_pipeTransform(123);
-
-    expect(result).toBe(JSON.stringify(123, null, 2));
-  });
-
-  it('| should handle boolean values', (): void => {
-    const result = DyFM_json_pipeTransform(true);
-
-    expect(result).toBe(JSON.stringify(true, null, 2));
-  });
-});
-

package/src/_modules/pipe/_collections/utils/pip-json-pipe.util.ts

@@ -1,18 +0,0 @@
-/**
- * This pipe will return a string of the object values separated by a comma
- * 
- * @example
- * 
- * ```html
- * {{ { a: 1, b: 2, c: 3 } | json }}
- * ```
- * will return `{ 
- *   "a":1,
- *   "b":2,
- *   "c":3
- * }`
- * 
- */
-export function DyFM_json_pipeTransform(value: any, depth: number = 2): string {
-  return JSON.stringify(value, null, depth);
-}

package/src/_modules/pipe/_collections/utils/pip-list-pipe.util.spec.ts

@@ -1,34 +0,0 @@
-
-import { DyFM_list_pipeTransform } from './pip-list-pipe.util';
-
-describe('| DyFM_list_pipeTransform', () => {
-  it('| should transform an array of numbers into a comma-separated string with spaces', () => {
-    const input: number[] = [1, 2, 3];
-    const expectedOutput: string = '1, 2, 3';
-    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
-  });
-
-  it('| should transform an array of strings into a comma-separated string with spaces', () => {
-    const input: string[] = ['apple', 'banana', 'cherry'];
-    const expectedOutput: string = 'apple, banana, cherry';
-    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
-  });
-
-  it('| should return an empty string for an empty array', () => {
-    const input: any[] = [];
-    const expectedOutput: string = '';
-    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
-  });
-
-  it('| should handle an array with a single element correctly', () => {
-    const input: number[] = [42];
-    const expectedOutput: string = '42';
-    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
-  });
-
-  it('| should handle an array with mixed types correctly', () => {
-    const input: any[] = [1, 'apple', true];
-    const expectedOutput: string = '1, apple, true';
-    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
-  });
-});

package/src/_modules/pipe/_collections/utils/pip-list-pipe.util.ts

@@ -1,25 +0,0 @@
-
-
-
-
-
-
-/**
- * This pipe will return a string of the array values separated by a comma
- * 
- * @example
- * 
- * ```html
- * {{ [1, 2, 3] | list }}
- * ```
- * will return `1, 2, 3`
- * 
- * ```html
- * {{ ['a', 'b', 'c'] | list }}
- * ```
- * will return `a, b, c`
- * 
- */
-export function DyFM_list_pipeTransform(value: any[]): string {
-  return value.toString().replace(/,/g, ', ');  
-}

package/src/_modules/pipe/_collections/utils/pip-multi-pipe-pipe.util.spec.ts

@@ -1,67 +0,0 @@
-
-import {
-  DyFM_AngularMultiPipeAvailable
-} from '../../_enums/pip.enum';
-import { DyFM_MultiPipe_Setting } from '../../_models/pip-multi-pipe-settings.type';
-import { DyFM_multiPipe_pipeTransform, DyFM_multiPipeAngularPipes } from './pip-multi-pipe-pipe.util';
-
-describe('| DyFM_multiPipe_pipeTransform', () => {
-  it('| should return the original value if no pipes are provided', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [];
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
-  });
-
-  /* it('| should return the original value if pipe has more than one key', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [{ pipe1: [], pipe2: [] }];
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
-  });
-
-  it('| should return the original value if pipe is not available', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [{ unknownPipe: [] }];
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
-  });
-
-  it('| should transform value using a known pipe without arguments', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: [] }];
-    DyFM_pipeTransforms[DyFM_Pipe.currency] = (val: unknown) => 'transformed';
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('transformed');
-  });
-
-  it('| should transform value using a known pipe with arguments', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: ['arg1'] }];
-    DyFM_pipeTransforms[DyFM_Pipe.currency] = (val: unknown, arg: string) => `transformed with ${arg}`;
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('transformed with arg1');
-  }); */
-
-  it('| should return the original value if Angular pipe is not defined', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_AngularMultiPipeAvailable.currency]: [] }];
-    const originalPipe = DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency];
-    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = null;
-    const result = DyFM_multiPipe_pipeTransform(value, pipes);
-    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = originalPipe;
-    expect(result).toBe(value);
-  });
-
-  it('| should transform value using a defined Angular pipe', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_AngularMultiPipeAvailable.currency]: ['arg1'] }];
-    const originalPipe = DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency];
-    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = (val: string, arg: string) => `angular transformed with ${arg}`;
-    const result = DyFM_multiPipe_pipeTransform(value, pipes);
-    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = originalPipe;
-    expect(result).toBe('angular transformed with arg1');
-  });
-
-  /* it('| should handle errors gracefully and return the original value', () => {
-    const value = 'test';
-    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: [] }];
-    DyFM_pipeTransforms[DyFM_Pipe.currency] = () => { throw new Error('Test error'); };
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
-  }); */
-});

package/src/_modules/pipe/_collections/utils/pip-multi-pipe-pipe.util.ts

@@ -1,227 +0,0 @@
-
-
-
-
-
-
-
-import { DyFM_RangeValue } from '../../../../_models/control-models/range-value.control-model';
-import {
-  DyFM_allDynamoPipes, DyFM_allMultiPipesAvailable, DyFM_AngularMultiPipeAvailable,
-  DyFM_MultiPipeAvailable, DyFM_Pipe
-} from '../../_enums/pip.enum';
-import { DyFM_MultiPipe_Setting } from '../../_models/pip-multi-pipe-settings.type';
-import { DyFM_pipeTransforms } from '../pip-transforms.const';
-
-
-export type DyFM_MultiPipeAngularPipes = {
-  [pipeName in DyFM_AngularMultiPipeAvailable]: (value: string, ...args: unknown[]) => string;
-};
-
-export const DyFM_multiPipeAngularPipes: DyFM_MultiPipeAngularPipes = {
-  [DyFM_AngularMultiPipeAvailable.currency]: null,
-  [DyFM_AngularMultiPipeAvailable.date]: null,
-  [DyFM_AngularMultiPipeAvailable.decimal]: null,
-  [DyFM_AngularMultiPipeAvailable.number]: null,
-  [DyFM_AngularMultiPipeAvailable.percent]: null,
-};
-
-/**
- * This pipe makes you able to use multiple pipes in one pipe
- * 
- * The pipes that are available are:
- * - country
- * - custom
- * - division
- * - list
- * - multiPipe
- * - objKey
- * - range
- * - region
- * - replace
- * - slider
- * - smartReplace
- * 
- * The angular pipes that are available are:
- * - currency
- * - date
- * - decimal
- * - number
- * - percent
- * 
- * (The custom pipe is basically usable for anything, 
- * you you even can create your own, combining multiple pipes)
- * 
- * @example
- * 
- * ```html
- * {{ 1000.123 | multiPipe: [
- *   { currency: [ 'USD' ] },
- *   { number: [ '1.0-1' ] },
- * ] }}
- * ```
- * will return `1,000.1`
- * 
- * ```html
- * {{ { from: 1.321, to: 10.123 } | multiPipe: [
- *   { range: [ 'from-to' ] },
- *   { number: [ '1.0-1' ] },
- * ] }}
- * ```
- * will return `1.3 - 10.1`
- * 
- * ```html
- * {{ 1000.123 | multiPipe: [
- *   { range: [ 'from-to' ] },
- *   { currency: [ 'EUR', 'symbol', '1.0-0' ] },
- *   { replace: [ ',', ' ' ] },
- * ] }}
- * ```
- * will return `€1 000`
- */
-export function DyFM_multiPipe_pipeTransform(
-  value: unknown, pipes: DyFM_MultiPipe_Setting[]
-): string | number | DyFM_RangeValue | any {
-  try {
-    /* console.log(
-      'applyPipes...',
-      '\nvalue:', value,
-      '\npipes:', DyFM_Object.clone(pipes)
-    ); */
-
-    stackPipes(pipes);
-
-    /* console.log('stacked pipes:', DyFM_Object.clone(pipes)); */
-
-    for (let i = 0; i < pipes.length; i++) {
-      const pipe: DyFM_MultiPipe_Setting = pipes[i];
-      /* pipes.forEach((pipe: DyFM_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: DyFM_MultiPipeAvailable = keys[0] as DyFM_MultiPipeAvailable;
-
-      if (!DyFM_allMultiPipesAvailable.includes(pipeName as DyFM_MultiPipeAvailable)) {
-        console.warn(
-          'DYNAMO WARNING: ' +
-          '\nMultiPipe: unknown pipe "' + pipeName + '"...',
-          '\nsorry, but this pipe is not supported by the MultiPipe yet.',
-          '\navailable pipes are: ' + DyFM_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 (DyFM_allDynamoPipes.includes(pipeName as DyFM_Pipe)) {
-        if (pipeArgs?.length) {
-          value = DyFM_pipeTransforms[pipeName](value, ...pipeArgs);
-        } else {
-          value = DyFM_pipeTransforms[pipeName](value);
-        }      
-      } else {
-        if (!DyFM_multiPipeAngularPipes[pipeName]) {
-          console.error(
-            'DYNAMO ERROR: ',
-            '\nMultiPipe: Angular pipe "' + pipeName + '" is not defined...',
-            '\nPlease set the pipe in the DyFM_multiPipeAngularPipes object.',
-          );
-
-          return value;
-        }
-        
-        value = DyFM_multiPipeAngularPipes[pipeName](value, ...pipeArgs);
-      }
-    }
-
-    return value;
-  } catch (error) {
-    console.error(
-      'DYNAMO ERROR: ',
-      '\nMultiPipe: something went wrong...',
-      '\nvalue:', value,
-      '\npipes:', pipes,
-      '\n\n',
-      error
-    );
-
-    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: DyFM_MultiPipe_Setting[]): void {
-  for (let i = 0; i < pipes.length; i++) {
-    if (i + 1 < pipes.length) {
-      const pipe: DyFM_MultiPipe_Setting = pipes[i];
-      const pipeName: DyFM_MultiPipeAvailable =
-        Object.keys(pipe)[0] as DyFM_MultiPipeAvailable;
-
-      switch (pipeName) {
-        case DyFM_Pipe.range:
-          const furtherPipesAfterRange: DyFM_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 DyFM_MultiPipe_Setting[]) = furtherPipesAfterRange;
-          }
-          break;
-
-        case DyFM_Pipe.smartReplace:
-          const furtherPipesAfterSR: DyFM_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?'
-            );
-          }
-
-          if ((pipe[pipeName][1] as any[])?.length) {
-            (pipe[pipeName][1] as any[]).push(...furtherPipesAfterSR);
-          } else {
-            (pipe[pipeName][1] as DyFM_MultiPipe_Setting[]) = furtherPipesAfterSR;
-          }
-          break;
-
-        default:
-          break;
-      }
-    }
-  }
-}