marcel/omni-tools
1
0
Fork 0
mirror of https://github.com/iib0011/omni-tools.git synced 2025-09-25 08:59:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

style: lint

Browse Source
This commit is contained in:
Ibrahima G. Coulibaly
2024-06-27 15:51:33 +01:00
parent 0c501055e6
commit d75043d282
3 changed files with 331 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
src/pages/list/sort/service.ts
View File

@@ -1,77 +1,90 @@
// utils function that choose the way of numeric sorting mixed types of array
function customNumericSort(a: number | string, b: number | string, increasing: boolean): number {
if (typeof a === 'number' && typeof b === 'number') {
let result: number = 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
}
function customNumericSort(
a: number | string,
b: number | string,
increasing: boolean
): number {
if (typeof a === 'number' && typeof b === 'number') {
let result: number = 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
increasing: boolean,
separator: string,
removeDuplicated: boolean // the value if the checkbox has been selected 1 else 0
array: any[], // array we build after parsing the input
increasing: boolean,
separator: string,
removeDuplicated: boolean // the value if the checkbox has been selected 1 else 0
) {
array.sort((a, b) => customNumericSort(a, b, increasing));
if (removeDuplicated) {
array = array.filter((item, index) => array.indexOf(item) === index);
}
return array.join(separator);
array.sort((a, b) => customNumericSort(a, b, increasing));
if (removeDuplicated) {
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, increasing: boolean): number {
let result: number = increasing ? (a.toString().length - b.toString().length) : (b.toString().length - a.toString().length);
return result;
function customLengthSort(
a: number | string,
b: number | string,
increasing: boolean
): number {
let result: number = 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
increasing: boolean, // select value has to be increasing for increasing order and decreasing for decreasing order
separator: string,
removeDuplicated: boolean // the value if the checkbox has been selected 1 else 0
array: any[], // array we build after parsing the input
increasing: boolean, // select value has to be increasing for increasing order and decreasing for decreasing order
separator: string,
removeDuplicated: boolean // the value if the checkbox has been selected 1 else 0
) {
array.sort((a, b) => customLengthSort(a, b, increasing));
if (removeDuplicated) {
array = array.filter((item, index) => array.indexOf(item) === index);
}
return array.join(separator);
array.sort((a, b) => customLengthSort(a, b, increasing));
if (removeDuplicated) {
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, caseSensitive: boolean): number {
const stringA : string = a.toString();
const stringB : string = b.toString();
function customAlphabeticSort(
a: number | string,
b: number | string,
caseSensitive: boolean
): number {
const stringA: string = a.toString();
const stringB: string = b.toString();
if (!caseSensitive) {
// Case-insensitive comparison
return stringA.toLowerCase().localeCompare(stringB.toLowerCase());
} else {
// Case-sensitive comparison
return stringA.charCodeAt(0) - stringB.charCodeAt(0);
}
if (!caseSensitive) {
// 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
increasing: boolean, // select value has to be "increasing" for increasing order and "decreasing" for decreasing order
separator: string,
removeDuplicated: boolean, // the value if the checkbox has been selected 1 else 0
caseSensitive: boolean // the value if the checkbox has been selected 1 else 0
)
{
array.sort((a, b) => customAlphabeticSort(a, b, caseSensitive));
if (!increasing){
array.reverse();
}
if (removeDuplicated) {
array = array.filter((item, index) => array.indexOf(item) === index);
}
return array.join(separator);
}
array: any[], // array we build after parsing the input
increasing: boolean, // select value has to be "increasing" for increasing order and "decreasing" for decreasing order
separator: string,
removeDuplicated: boolean, // the value if the checkbox has been selected 1 else 0
caseSensitive: boolean // the value if the checkbox has been selected 1 else 0
) {
array.sort((a, b) => customAlphabeticSort(a, b, caseSensitive));
if (!increasing) {
array.reverse();
}
if (removeDuplicated) {
array = array.filter((item, index) => array.indexOf(item) === index);
}
return array.join(separator);
}

406
src/pages/list/sort/sort.service.test.ts
View File

@@ -1,183 +1,263 @@
// Import necessary modules and functions
import { describe, it, expect } from 'vitest';
import { describe, expect, it } from 'vitest';
import { alphabeticSort, lengthSort, numericSort } from './service';
import { BlobOptions } from 'buffer';
// 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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = false;
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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = false;
const result = numericSort(array, increasing, separator, removeDuplicated);
expect(result).toBe('2, 2, 4, 5, 7, 8, 9');
const result = numericSort(array, increasing, separator, removeDuplicated);
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 increasing: boolean = false;
const separator = ' - ';
const removeDuplicated: boolean = true;
const result = numericSort(array, increasing, separator, removeDuplicated);
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const result = numericSort(array, increasing, separator, removeDuplicated);
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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = false;
const result = lengthSort(array, increasing, separator, removeDuplicated);
expect(result).toBe('3, 12, 126, 1523, 415689521');
});
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 increasing: boolean = false;
const separator = ' - ';
const removeDuplicated: boolean = true;
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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = true;
const result = numericSort(array, increasing, separator, removeDuplicated);
expect(result).toBe('9 - 7 - 6 - 4 - 2');
const result = lengthSort(array, increasing, separator, removeDuplicated);
expect(result).toBe('3, 12, 126, 1523, 415689521');
});
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const result = lengthSort(array, increasing, separator, removeDuplicated);
expect(result).toBe('d p h 9 7 ddd nfg 6555 5556');
});
});
const result = numericSort(array, increasing, separator, removeDuplicated);
expect(result).toBe('5 6 7 9 d h n p');
// 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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = false;
const caseSensitive: boolean = false;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
expect(result).toBe('apple, lemon, orange, pineaple');
});
// 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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = false;
const result = lengthSort(array, increasing, separator, removeDuplicated);
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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = true;
const result = lengthSort(array, increasing, separator, removeDuplicated);
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const result = lengthSort(array, increasing, separator, removeDuplicated);
expect(result).toBe('d p h 9 7 ddd nfg 6555 5556');
});
it('should sort a list of string in decreasing order with comma separator ', () => {
const array: any[] = ['apple', 'pineaple', 'lemon', 'orange'];
const increasing: boolean = false;
const separator = ', ';
const removeDuplicated: boolean = false;
const caseSensitive: boolean = false;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
expect(result).toBe('pineaple, orange, lemon, apple');
});
// 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 increasing: boolean = true;
const separator = ', ';
const removeDuplicated: boolean = false;
const caseSensitive: boolean = false;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = false;
const separator = ', ';
const removeDuplicated: boolean = false;
const caseSensitive: boolean = false;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = false;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = false;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = false;
const caseSensitive: boolean = true;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(array, increasing, separator, removeDuplicated, caseSensitive);
expect(result).toBe('pineaple lemon Orange Apple @ 9 1 +');
});
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = false;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = false;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = false;
const caseSensitive: boolean = true;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
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 increasing: boolean = true;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
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 increasing: boolean = false;
const separator = ' ';
const removeDuplicated: boolean = true;
const caseSensitive: boolean = true;
const result = alphabeticSort(
array,
increasing,
separator,
removeDuplicated,
caseSensitive
);
expect(result).toBe('pineaple lemon Orange Apple @ 9 1 +');
});
});
});