Merge remote-tracking branch 'origin/main'

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

@@ -0,0 +1,62 @@
+import { expect, describe, it } from 'vitest';
+import { duplicateList } from './service';
+
+describe('duplicateList function', () => {
+    it('should duplicate elements correctly with symbol split', () => {
+        const input = "Hello World";
+        const result = duplicateList('symbol', ' ', ' ', input, true, false, 2);
+        expect(result).toBe("Hello World Hello World");
+    });
+
+    it('should duplicate elements correctly with regex split', () => {
+        const input = "Hello||World";
+        const result = duplicateList('regex', '\\|\\|', ' ', input, true, false, 2);
+        expect(result).toBe("Hello World Hello World");
+    });
+
+    it('should handle fractional duplication', () => {
+        const input = "Hello World";
+        const result = duplicateList('symbol', ' ', ' ', input, true, false, 1.5);
+        expect(result).toBe("Hello World Hello");
+    });
+
+    it('should handle reverse option correctly', () => {
+        const input = "Hello World";
+        const result = duplicateList('symbol', ' ', ' ', input, true, true, 2);
+        expect(result).toBe("Hello World World Hello");
+    });
+
+    it('should handle concatenate option correctly', () => {
+        const input = "Hello World";
+        const result = duplicateList('symbol', ' ', ' ', input, false, false, 2);
+        expect(result).toBe("Hello Hello World World");
+    });
+
+    it('should handle interweaving option correctly', () => {
+        const input = "Hello World";
+        const result = duplicateList('symbol', ' ', ' ', input, false, false, 2);
+        expect(result).toBe("Hello Hello World World");
+    });
+
+    it('should throw an error for negative copies', () => {
+        expect(() => duplicateList('symbol', ' ', ' ', "Hello World", true, false, -1)).toThrow("Number of copies cannot be negative");
+    });
+
+    it('should handle interweaving option correctly 2', () => {
+        const input = "je m'appelle king";
+        const result = duplicateList('symbol', ' ', ', ', input, false, true, 2.1);
+        expect(result).toBe("je, king, m'appelle, m'appelle, king, je");
+    });
+
+    it('should handle interweaving option correctly 3', () => {
+        const input = "je m'appelle king";
+        const result = duplicateList('symbol', ' ', ', ', input, false, true, 1);
+        expect(result).toBe("je, m'appelle, king");
+    });
+
+    it('should handle interweaving option correctly 3', () => {
+        const input = "je m'appelle king";
+        const result = duplicateList('symbol', ' ', ', ', input, true, true, 2.7);
+        expect(result).toBe("je, m'appelle, king, king, m'appelle, je, king, m'appelle");
+    });
+});

src/pages/list/duplicate/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 Duplicate() {
+  return <Box>Lorem ipsum</Box>;
+}

src/pages/list/duplicate/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: 'Duplicate',
+  path: 'duplicate',
+  // image,
+  description: '',
+  shortDescription: '',
+  keywords: ['duplicate'],
+  component: lazy(() => import('./index'))
+});

src/pages/list/duplicate/service.ts

@@ -0,0 +1,69 @@
+export type SplitOperatorType = 'symbol' | 'regex';
+
+function interweave(
+    array1: string[],
+    array2: string[]) {
+    const result: string[] = [];
+    const maxLength = Math.max(array1.length, array2.length);
+
+    for (let i = 0; i < maxLength; i++) {
+        if (i < array1.length) result.push(array1[i]);
+        if (i < array2.length) result.push(array2[i]);
+    }
+    return result;
+}
+function duplicate(
+    input: string[],
+    concatenate: boolean,
+    reverse: boolean,
+    copy?: number
+) {
+    if (copy) {
+        if (copy > 0) {
+            let result: string[] = [];
+            let toAdd: string[] = [];
+            let WholePart: string[] = [];
+            let fractionalPart: string[] = [];
+            const whole = Math.floor(copy);
+            const fractional = copy - whole;
+            if (!reverse) {
+                WholePart = concatenate ? Array(whole).fill(input).flat() : Array(whole - 1).fill(input).flat();
+                fractionalPart = input.slice(0, Math.floor(input.length * fractional));
+                toAdd = WholePart.concat(fractionalPart);
+                result = concatenate ? WholePart.concat(fractionalPart) : interweave(input, toAdd);
+            } else {
+                WholePart = Array(whole - 1).fill(input).flat().reverse()
+                fractionalPart = input.slice().reverse().slice(0, Math.floor(input.length * fractional));
+                toAdd = WholePart.concat(fractionalPart);
+                result = concatenate ? input.concat(toAdd) : interweave(input, toAdd);
+            }
+
+            return result;
+        }
+        throw new Error("Number of copies cannot be negative");
+    }
+    throw new Error("Number of copies must be a valid number");
+}
+
+export function duplicateList(
+    splitOperatorType: SplitOperatorType,
+    splitSeparator: string,
+    joinSeparator: string,
+    input: string,
+    concatenate: boolean,
+    reverse: boolean,
+    copy?: number
+): string {
+    let array: string[];
+    let result: string[];
+    switch (splitOperatorType) {
+        case 'symbol':
+            array = input.split(splitSeparator);
+            break;
+        case 'regex':
+            array = input.split(new RegExp(splitSeparator)).filter(item => item !== '');
+            break;
+    }
+    result = duplicate(array, concatenate, reverse, copy);
+    return result.join(joinSeparator);
+}

src/pages/list/index.ts

@@ -1,3 +1,4 @@
+import { tool as listDuplicate } from './duplicate/meta';
 import { tool as listUnwrap } from './unwrap/meta';
 import { tool as listReverse } from './reverse/meta';
 import { tool as listFindUnique } from './find-unique/meta';

src/pages/string/create-palindrome/create-palindrome.service.test.ts

@@ -0,0 +1,66 @@
+import { expect, describe, it } from 'vitest';
+ import { createPalindromeList, createPalindrome } from './service';
+
+describe('createPalindrome', () => {
+    test('should create palindrome by reversing the entire string', () => {
+        const input = 'hello';
+        const result = createPalindrome(input, true);
+        expect(result).toBe('helloolleh');
+    });
+
+    test('should create palindrome by reversing the string excluding the last character', () => {
+        const input = 'hello';
+        const result = createPalindrome(input, false);
+        expect(result).toBe('hellolleh');
+    });
+
+    test('should return an empty string if input is empty', () => {
+        const input = '';
+        const result = createPalindrome(input, true);
+        expect(result).toBe('');
+    });
+});
+
+describe('createPalindromeList', () => {
+    test('should create palindrome for single-line input', () => {
+        const input = 'hello';
+        const result = createPalindromeList(input, true, false);
+        expect(result).toBe('helloolleh');
+    });
+
+    test('should create palindrome for single-line input considering trailing spaces', () => {
+        const input = 'hello ';
+        const result = createPalindromeList(input, true, false);
+        expect(result).toBe('hello  olleh');
+    });
+
+    test('should create palindrome for single-line input ignoring trailing spaces if lastChar is set to false', () => {
+        const input = 'hello ';
+        const result = createPalindromeList(input, true, false);
+        expect(result).toBe('hello  olleh');
+    });
+
+    test('should create palindrome for multi-line input', () => {
+        const input = 'hello\nworld';
+        const result = createPalindromeList(input, true, true);
+        expect(result).toBe('helloolleh\nworlddlrow');
+    });
+
+    test('should create palindrome for no multi-line input', () => {
+        const input = 'hello\nworld\n';
+        const result = createPalindromeList(input, true, false);
+        expect(result).toBe('hello\nworld\n\ndlrow\nolleh');
+    });
+
+    test('should handle multi-line input with lastChar set to false', () => {
+        const input = 'hello\nworld';
+        const result = createPalindromeList(input, false, true);
+        expect(result).toBe('hellolleh\nworldlrow');
+    });
+
+    test('should return an empty string if input is empty', () => {
+        const input = '';
+        const result = createPalindromeList(input, true, false);
+        expect(result).toBe('');
+    });
+});

src/pages/string/create-palindrome/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 CreatePalindrome() {
+  return <Box>Lorem ipsum</Box>;
+}

src/pages/string/create-palindrome/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('string', {
+  name: 'Create palindrome',
+  path: 'create-palindrome',
+  // image,
+  description: '',
+  shortDescription: '',
+  keywords: ['create', 'palindrome'],
+  component: lazy(() => import('./index'))
+});

src/pages/string/create-palindrome/service.ts

@@ -0,0 +1,35 @@
+import { reverseString } from 'utils/string'
+
+export function createPalindrome(
+    input: string,
+    lastChar: boolean  // only checkbox is need here to handle it [instead of two combo boxes]
+) {
+    if (!input) return '';
+    let result: string;
+    let reversedString: string;
+
+    // reverse the whole input if lastChar enabled
+    reversedString = lastChar ? reverseString(input) : reverseString(input.slice(0, -1));
+    result = input.concat(reversedString);
+    return result;
+}
+
+export function createPalindromeList(
+    input: string,
+    lastChar: boolean,
+    multiLine: boolean
+): string {
+    if (!input) return '';
+    let array: string[];
+    let result: string[] = [];
+
+    if (!multiLine) return createPalindrome(input, lastChar);
+    else {
+        array = input.split('\n');
+        for (const word of array) {
+            result.push(createPalindrome(word, lastChar));
+        }
+    }
+    return result.join('\n');
+
+}

src/pages/string/extract-substring/extract-substring.service.test.ts

@@ -0,0 +1,57 @@
+import { expect, describe, it } from 'vitest';
+import { extractSubstring } from './service';
+
+describe('extractSubstring', () => {
+    it('should extract a substring from single-line input', () => {
+        const input = 'hello world';
+        const result = extractSubstring(input, 1, 4, false, false);
+        expect(result).toBe('hell');
+    });
+
+    it('should extract and reverse a substring from single-line input', () => {
+        const input = 'hello world';
+        const result = extractSubstring(input, 1, 5, false, true);
+        expect(result).toBe('olleh');
+    });
+
+    it('should extract substrings from multi-line input', () => {
+        const input = 'hello\nworld';
+        const result = extractSubstring(input, 1, 5, true, false);
+        expect(result).toBe('hello\nworld');
+    });
+
+    it('should extract and reverse substrings from multi-line input', () => {
+        const input = 'hello\nworld';
+        const result = extractSubstring(input, 1, 4, true, true);
+        expect(result).toBe('lleh\nlrow');
+    });
+
+    it('should handle empty input', () => {
+        const input = '';
+        const result = extractSubstring(input, 1, 5, false, false);
+        expect(result).toBe('');
+    });
+
+    it('should handle start and length out of bounds', () => {
+        const input = 'hello';
+        const result = extractSubstring(input, 10, 5, false, false);
+        expect(result).toBe('');
+    });
+
+    it('should handle negative start and length', () => {
+        expect(() => extractSubstring('hello', -1, 5, false, false)).toThrow("Start index must be greater than zero.");
+        expect(() => extractSubstring('hello', 1, -5, false, false)).toThrow("Length value must be greater than or equal to zero.");
+    });
+
+    it('should handle zero length', () => {
+        const input = 'hello';
+        const result = extractSubstring(input, 1, 0, false, false);
+        expect(result).toBe('');
+    });
+
+    it('should work', () => {
+        const input = 'je me nomme king\n22 est mon chiffre';
+        const result = extractSubstring(input, 12, 7, true, false);
+        expect(result).toBe(' king\nchiffre');
+    });
+});

src/pages/string/extract-substring/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 ExtractSubstring() {
+  return <Box>Lorem ipsum</Box>;
+}

src/pages/string/extract-substring/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('string', {
+  name: 'Extract substring',
+  path: 'extract-substring',
+  // image,
+  description: '',
+  shortDescription: '',
+  keywords: ['extract', 'substring'],
+  component: lazy(() => import('./index'))
+});