create tool, implementing alphabeticSort and NumericSort and writing testCases

src/pages/list/index.ts

@@ -0,0 +1,2 @@
+import { tool as listSort } from './sort/meta';
+export const listTools = [];

src/pages/list/sort/index.tsx

@@ -0,0 +1,11 @@
+import { Box } from '@mui/material';
+import React from 'react';
+import * as Yup from 'yup';
+
+const initialValues = {};
+const validationSchema = Yup.object({
+  // splitSeparator: Yup.string().required('The separator is required')
+});
+export default function Sort() {
+  return <Box>Lorem ipsum</Box>;
+}

src/pages/list/sort/meta.ts

@@ -0,0 +1,13 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+// import image from '@assets/text.png';
+
+export const tool = defineTool('list', {
+  name: 'Sort',
+  path: 'sort',
+  // image,
+  description: '',
+  shortDescription: '',
+  keywords: ['sort'],
+  component: lazy(() => import('./index'))
+});

src/pages/list/sort/service.ts

@@ -0,0 +1,81 @@
+import { string } from "yup";
+
+// utils function that choose the way of numeric sorting mixed types of array
+function customNumericSort(a: number | string, b: number | string, order: string): number {
+    if (typeof a === 'number' && typeof b === 'number') {
+        let result: number = order === "increasing" ? (a - b) : (b - a);
+        return result;
+    } else if (typeof a === 'string' && typeof b === 'string') {
+        return a.localeCompare(b); // Lexicographical comparison for strings
+    } else if (typeof a === 'number' && typeof b === 'string') {
+        return -1; // Numbers before strings
+    } else {
+        return 1; // Strings after numbers
+    }
+}
+
+export function numericSort(
+    array: any[], // array we build after parsing the input
+    order: string, // select value has to be increasing for increasing order and decreasing for decreasing order (set a default value)
+    separator: string,
+    remove_duplicated: number // the value if the checkbox has been selected 1 else 0
+) {
+    array.sort((a, b) => customNumericSort(a, b, order));
+    if (remove_duplicated === 1) {
+        array = array.filter((item, index) => array.indexOf(item) === index);
+    }
+    return array.join(separator);
+}
+
+// utils function that choose the way of numeric sorting mixed types of array
+function customLengthSort(a: number | string, b: number | string, order: string): number {
+    let result: number = order === "increasing" ? (a.toString().length - b.toString().length) : (b.toString().length - a.toString().length);
+    return result;
+}
+
+export function lengthSort(
+    array: any[], // array we build after parsing the input
+    order: string, // select value has to be increasing for increasing order and decreasing for decreasing order
+    separator: string,
+    remove_duplicated: number // the value if the checkbox has been selected 1 else 0
+) {
+    array.sort((a, b) => customLengthSort(a, b, order));
+    if (remove_duplicated === 1) {
+        array = array.filter((item, index) => array.indexOf(item) === index);
+    }
+    return array.join(separator);
+}
+
+// Utils function that chooses the way of alphabetic sorting mixed types of array
+function customAlphabeticSort(a: number | string, b: number | string, case_sensitive: number): number {
+    const stringA : string = a.toString();
+    const stringB : string = b.toString();
+
+    if (case_sensitive === 0) {
+        // Case-insensitive comparison
+        return stringA.toLowerCase().localeCompare(stringB.toLowerCase());
+    } else {
+        // Case-sensitive comparison
+        return stringA.charCodeAt(0) - stringB.charCodeAt(0);
+    }
+}
+
+export function alphabeticSort(
+    array: any[], // array we build after parsing the input
+    order: string, // select value has to be "increasing" for increasing order and "decreasing" for decreasing order
+    separator: string,
+    remove_duplicated: number, // the value if the checkbox has been selected 1 else 0
+    case_sensitive: number // the value if the checkbox has been selected 1 else 0
+) 
+{
+    array.sort((a, b) => customAlphabeticSort(a, b, case_sensitive));
+    if (order === "decreasing"){
+        array.reverse();
+    } 
+    if (remove_duplicated === 1) {
+        array = array.filter((item, index) => array.indexOf(item) === index);
+    }
+    return array.join(separator);
+
+    
+}

src/pages/list/sort/sort.service.test.ts

@@ -0,0 +1,182 @@
+// Import necessary modules and functions
+import { describe, it, expect } from 'vitest';
+import { alphabeticSort, lengthSort, numericSort } from './service';
+
+// Define test cases for the numericSort function
+describe('numericSort function', () => {
+    it('should sort a list in increasing order with comma separator not removeduplicated elements', () => {
+        const array: number[] = [9, 8, 7, 4, 2, 2, 5];
+        const order: string = 'increasing';
+        const separator = ', ';
+        const remove_duplicated: number = 0;
+
+        const result = numericSort(array, order, separator, remove_duplicated);
+        expect(result).toBe('2, 2, 4, 5, 7, 8, 9');
+    });
+
+    it('should sort a list in decreasing order with " - " separator and remove duplicated elements', () => {
+        const array: number[] = [2, 4, 4, 9, 6, 6, 7];
+        const order: string = 'decreasing';
+        const separator = ' - ';
+        const remove_duplicated: number = 1;
+
+
+        const result = numericSort(array, order, separator, remove_duplicated);
+        expect(result).toBe('9 - 7 - 6 - 4 - 2');
+    });
+
+    it('should sort a list with numbers and characters and remove duplicated elements', () => {
+        const array: any[] = ['d','d', 'n', 'p', 'h', 'h', 6, 9, 7, 5];
+        const order: string = 'increasing';
+        const separator = ' ';
+        const remove_duplicated: number = 1;
+
+
+        const result = numericSort(array, order, separator, remove_duplicated);
+        expect(result).toBe('5 6 7 9 d h n p');
+    });
+
+    // Define test cases for the lengthSort function
+    describe('lengthSort function', () => {
+        it('should sort a list of number by length in increasing order with comma separator ', () => {
+            const array: number[] = [415689521, 3, 126, 12, 1523];
+            const order: string = 'increasing';
+            const separator = ', ';
+            const remove_duplicated: number = 0;
+
+            const result = lengthSort(array, order, separator, remove_duplicated);
+            expect(result).toBe('3, 12, 126, 1523, 415689521');
+        });
+
+        it('should sort a list of number by length in increasing order and remove duplicated elements ', () => {
+            const array: number[] = [415689521, 3, 3, 126, 12, 12,  1523];
+            const order: string = 'increasing';
+            const separator = ', ';
+            const remove_duplicated: number = 1;
+
+            const result = lengthSort(array, order, separator, remove_duplicated);
+            expect(result).toBe('3, 12, 126, 1523, 415689521');
+        });
+
+        it('should sort a mixed array by length in increasing order ', () => {
+            const array: any[] = ['ddd', 'd', 'nfg', 'p', 'h', 'h', 6555, 9, 7, 5556];
+            const order: string = 'increasing';
+            const separator = ' ';
+            const remove_duplicated: number = 1;
+
+            const result = lengthSort(array, order, separator, remove_duplicated);
+            expect(result).toBe('d p h 9 7 ddd nfg 6555 5556');
+        });
+
+
+    });
+
+    // Define test cases for the alphabeticSort function
+    describe('alphabeticSort function', () => {
+        // NON CASE SENSITIVE TEST
+        it('should sort a list of string in increasing order with comma separator ', () => {
+            const array: any[] = ['apple', 'pineaple', 'lemon', 'orange'];
+            const order: string = 'increasing';
+            const separator = ', ';
+            const remove_duplicated: number = 0;
+            const case_sensitive: number = 0;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('apple, lemon, orange, pineaple');
+        });
+
+        it('should sort a list of string in decreasing order with comma separator ', () => {
+            const array: any[] = ['apple', 'pineaple', 'lemon', 'orange'];
+            const order: string = 'decreasing';
+            const separator = ', ';
+            const remove_duplicated: number = 0;
+            const case_sensitive: number = 0;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('pineaple, orange, lemon, apple');
+        });
+
+        it('should sort a list of string and symbols (uppercase and lower) in increasing order with comma separator ', () => {
+            const array: any[] = ['Apple', 'pineaple', 'lemon', 'Orange', 1, 9, '@', '+'];
+            const order: string = 'increasing';
+            const separator = ' ';
+            const remove_duplicated: number = 1;
+            const case_sensitive: number = 0;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('@ + 1 9 Apple lemon Orange pineaple');
+        }); 
+
+        it('should sort a list of string and symbols (uppercase and lower) in decreasing order with comma separator ', () => {
+            const array: any[] = ['Apple', 'pineaple', 'lemon', 'Orange', 1, 9, '@', '+'];
+            const order: string = 'decreasing';
+            const separator = ' ';
+            const remove_duplicated: number = 1;
+            const case_sensitive: number = 0;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('pineaple Orange lemon Apple 9 1 + @');
+        }); 
+
+
+        // CASE SENSITIVE TEST
+        it('should sort a list of string (uppercase) in decreasing order with comma separator ', () => {
+            const array: any[] = ['Apple', 'Pineaple', 'Lemon', 'Orange'];
+            const order: string = 'decreasing';
+            const separator = ' ';
+            const remove_duplicated: number = 0;
+            const case_sensitive: number = 1;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('Pineaple Orange Lemon Apple');
+        });
+
+        it('should sort a list of string (uppercase and lowercase) in increasing order with comma separator ', () => {
+            const array: any[] = ['Apple', 'pineaple', 'lemon', 'Orange', 1, 9];
+            const order: string = 'increasing';
+            const separator = ' ';
+            const remove_duplicated: number = 1;
+            const case_sensitive: number = 1;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('1 9 Apple Orange lemon pineaple');
+        });  
+        
+        it('should sort a list of string (uppercase and lower) in decreasing order with comma separator ', () => {
+            const array: any[] = ['Apple', 'pineaple', 'lemon', 'Orange', 1, 9];
+            const order: string = 'decreasing';
+            const separator = ' ';
+            const remove_duplicated: number = 1;
+            const case_sensitive: number = 1;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('pineaple lemon Orange Apple 9 1');
+        }); 
+
+        it('should sort a list of string and symbols (uppercase and lower) in decreasing order with comma separator ', () => {
+            const array: any[] = ['Apple', 'pineaple', 'lemon', 'Orange', 1, 9, '@', '+'];
+            const order: string = 'increasing';
+            const separator = ' ';
+            const remove_duplicated: number = 1;
+            const case_sensitive: number = 1;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('+ 1 9 @ Apple Orange lemon pineaple');
+        });
+
+        it('should sort a list of string and symbols (uppercase and lower) in decreasing order with comma separator ', () => {
+            const array: any[] = ['Apple', 'pineaple', 'lemon', 'Orange', 1, 9, '@', '+'];
+            const order: string = 'decreasing';
+            const separator = ' ';
+            const remove_duplicated: number = 1;
+            const case_sensitive: number = 1;
+
+            const result = alphabeticSort(array, order, separator, remove_duplicated, case_sensitive);
+            expect(result).toBe('pineaple lemon Orange Apple @ 9 1 +');
+        }); 
+
+
+
+
+    });
+});