Merge remote-tracking branch 'origin/main'

src/pages/tools/string/index.ts

@@ -1,4 +1,7 @@
 import { tool as stringRemoveDuplicateLines } from './remove-duplicate-lines/meta';
+import { tool as stringRotate } from './rotate/meta';
+import { tool as stringQuote } from './quote/meta';
+import { tool as stringRot13 } from './rot13/meta';
 import { tool as stringReverse } from './reverse/meta';
 import { tool as stringRandomizeCase } from './randomize-case/meta';
 import { tool as stringUppercase } from './uppercase/meta';
@@ -9,13 +12,15 @@ import { tool as stringToMorse } from './to-morse/meta';
 import { tool as stringSplit } from './split/meta';
 import { tool as stringJoin } from './join/meta';
 import { tool as stringReplace } from './text-replacer/meta';
+import { tool as stringRepeat } from './repeat/meta';
 
 export const stringTools = [
   stringSplit,
   stringJoin,
   stringRemoveDuplicateLines,
   stringToMorse,
-  stringReplace
+  stringReplace,
+  stringRepeat
   // stringReverse,
   // stringRandomizeCase,
   // stringUppercase,

src/pages/tools/string/quote/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 Quote() {
+  return <Box>Lorem ipsum</Box>;
+}

src/pages/tools/string/quote/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: 'Quote',
+  path: 'quote',
+  icon: 'proicons:quote',
+  description: '',
+  shortDescription: '',
+  keywords: ['quote'],
+  component: lazy(() => import('./index'))
+});

src/pages/tools/string/quote/quote.service.test.ts

@@ -0,0 +1,62 @@
+import { expect, describe, it } from 'vitest';
+import { quote, stringQuoter } from './service';
+
+describe('quote function', () => {
+  it('quotes a word with single quotes', () => {
+    expect(quote('Hello', "'", "'", false)).toBe("'Hello'");
+  });
+
+  it('quotes a word with double quotes', () => {
+    expect(quote('World', '"', '"', true)).toBe('"World"');
+  });
+
+  it('does not re-quote already quoted word', () => {
+    expect(quote('"Goodbye"', '"', '"', false)).toBe('"Goodbye"');
+  });
+
+  it('handles empty word when emptyQuoting is true', () => {
+    expect(quote('', "'", "'", false)).toBe("''");
+  });
+
+  it('handles empty word when emptyQuoting is false', () => {
+    expect(quote('', "'", "'", false)).toBe("''"); // Replace with expected behavior
+  });
+});
+
+describe('stringQuoter function', () => {
+  it('quotes a multi-line input with single quotes', () => {
+    const input = 'Hello\nWorld\n';
+    const expected = "'Hello'\n'World'\n''";
+    expect(stringQuoter(input, "'", "'", false, true, true)).toBe(expected);
+  });
+
+  it('handles empty lines when emptyQuoting is true', () => {
+    const input = 'Hello\n\nWorld';
+    const expected = "'Hello'\n''\n'World'";
+    expect(stringQuoter(input, "'", "'", false, true, true)).toBe(expected);
+  });
+
+  it('does not quote empty lines when emptyQuoting is false', () => {
+    const input = 'Hello\n\nWorld';
+    const expected = "'Hello'\n\n'World'";
+    expect(stringQuoter(input, "'", "'", false, false, true)).toBe(expected);
+  });
+
+  it('quotes a single-line input with double quotes', () => {
+    const input = 'Hello';
+    const expected = '"Hello"';
+    expect(stringQuoter(input, '"', '"', true, true, false)).toBe(expected);
+  });
+
+  it('handles empty input', () => {
+    const input = '';
+    const expected = '';
+    expect(stringQuoter(input, "'", "'", false, true, false)).toBe(expected);
+  });
+
+  it('handles spaces input', () => {
+    const input = ' ';
+    const expected = "' '";
+    expect(stringQuoter(input, "'", "'", false, true, false)).toBe(expected);
+  });
+});

src/pages/tools/string/quote/service.ts

@@ -0,0 +1,57 @@
+export function quote(
+  word: string,
+  leftQuote: string,
+  rightQuote: string,
+  doubleQuotation: boolean
+): string {
+  const array: string[] = word.split('');
+
+  // Check if double quotation is enabled and adjust accordingly
+  if (doubleQuotation) {
+    array.unshift(leftQuote);
+    array.push(rightQuote);
+  } else {
+    // Check if the word is already quoted correctly
+    if (array[0] === leftQuote && array[array.length - 1] === rightQuote) {
+      return word;
+    }
+
+    // Append quotes if not already quoted
+    array.unshift(leftQuote);
+    array.push(rightQuote);
+  }
+
+  return array.join('');
+}
+
+export function stringQuoter(
+  input: string,
+  leftQuote: string,
+  rightQuote: string,
+  doubleQuotation: boolean,
+  emptyQuoting: boolean,
+  multiLine: boolean
+) {
+  if (!input) {
+    return '';
+  }
+  let arrayOfString: string[] = [];
+  const result: string[] = [];
+  if (multiLine) {
+    arrayOfString = input.split('\n');
+  } else {
+    arrayOfString.push(input);
+  }
+  for (const word of arrayOfString) {
+    if (word === '') {
+      if (emptyQuoting) {
+        result.push(quote(word, leftQuote, rightQuote, doubleQuotation));
+      } else {
+        result.push(word);
+      }
+    } else {
+      result.push(quote(word, leftQuote, rightQuote, doubleQuotation));
+    }
+  }
+  return result.join('\n');
+}

src/pages/tools/string/repeat/index.tsx

@@ -0,0 +1,114 @@
+import { Box } from '@mui/material';
+import { useState } from 'react';
+import ToolTextResult from '@components/result/ToolTextResult';
+import { GetGroupsType } from '@components/options/ToolOptions';
+import { repeatText } from './service';
+import TextFieldWithDesc from '@components/options/TextFieldWithDesc';
+import ToolTextInput from '@components/input/ToolTextInput';
+import { initialValues, InitialValuesType } from './initialValues';
+import ToolContent from '@components/ToolContent';
+import { CardExampleType } from '@components/examples/ToolExamples';
+import { ToolComponentProps } from '@tools/defineTool';
+
+const exampleCards: CardExampleType<InitialValuesType>[] = [
+  {
+    title: 'Repeat word five times',
+    description: 'Repeats "Hello!" five times without any delimiter.',
+    sampleText: 'Hello! ',
+    sampleResult: 'Hello! Hello! Hello! Hello! Hello! ',
+    sampleOptions: {
+      textToRepeat: 'Hello! ',
+      repeatAmount: '5',
+      delimiter: ''
+    }
+  },
+  {
+    title: 'Repeat phrase with comma',
+    description:
+      'Repeats "Good job" three times, separated by commas and spaces.',
+    sampleText: 'Good job',
+    sampleResult: 'Good job, Good job, Good job',
+    sampleOptions: {
+      textToRepeat: 'Good job',
+      repeatAmount: '3',
+      delimiter: ', '
+    }
+  },
+  {
+    title: 'Repeat number with space',
+    description: 'Repeats the number "42" four times, separated by spaces.',
+    sampleText: '42',
+    sampleResult: '42 42 42 42',
+    sampleOptions: {
+      textToRepeat: '42',
+      repeatAmount: '4',
+      delimiter: ' '
+    }
+  }
+];
+
+export default function Replacer({ title }: ToolComponentProps) {
+  const [input, setInput] = useState<string>('');
+  const [result, setResult] = useState<string>('');
+
+  function compute(optionsValues: InitialValuesType, input: string) {
+    setResult(repeatText(optionsValues, input));
+  }
+
+  const getGroups: GetGroupsType<InitialValuesType> = ({
+    values,
+    updateField
+  }) => [
+    {
+      title: 'Text Repetitions',
+      component: (
+        <Box>
+          <TextFieldWithDesc
+            description={'Number of repetitions.'}
+            placeholder="Number"
+            value={values.repeatAmount}
+            onOwnChange={(val) => updateField('repeatAmount', val)}
+            type={'number'}
+          />
+        </Box>
+      )
+    },
+    {
+      title: 'Repetitions Delimiter',
+      component: (
+        <Box>
+          <TextFieldWithDesc
+            description={'Delimiter for output copies.'}
+            placeholder="Delimiter"
+            value={values.delimiter}
+            onOwnChange={(val) => updateField('delimiter', val)}
+            type={'text'}
+          />
+        </Box>
+      )
+    }
+  ];
+
+  return (
+    <ToolContent
+      title={title}
+      initialValues={initialValues}
+      getGroups={getGroups}
+      compute={compute}
+      input={input}
+      setInput={setInput}
+      inputComponent={
+        <ToolTextInput title={'Input text'} value={input} onChange={setInput} />
+      }
+      resultComponent={
+        <ToolTextResult title={'Repeated text'} value={result} />
+      }
+      toolInfo={{
+        title: 'Repeat text',
+        description:
+          'This tool allows you to repeat a given text multiple times with an optional separator.'
+      }}
+      exampleCards={exampleCards}
+    />
+  );
+}

src/pages/tools/string/repeat/initialValues.ts

@@ -0,0 +1,11 @@
+export type InitialValuesType = {
+  textToRepeat: string;
+  repeatAmount: string;
+  delimiter: string;
+};
+
+export const initialValues: InitialValuesType = {
+  textToRepeat: '',
+  repeatAmount: '5',
+  delimiter: ''
+};

src/pages/tools/string/repeat/meta.ts

@@ -0,0 +1,13 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('string', {
+  name: 'Repeat text',
+  path: 'repeat',
+  shortDescription: 'Repeat text multiple times',
+  icon: 'material-symbols-light:replay',
+  description:
+    'This tool allows you to repeat a given text multiple times with an optional separator.',
+  keywords: ['text', 'repeat'],
+  component: lazy(() => import('./index'))
+});

src/pages/tools/string/repeat/repeatText.service.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { repeatText } from './service';
+import { initialValues } from './initialValues';
+
+describe('repeatText function', () => {
+  it('should repeat the letter correctly', () => {
+    const text = 'i';
+    const repeatAmount = '5';
+    const result = repeatText({ ...initialValues, repeatAmount }, text);
+    expect(result).toBe('iiiii');
+  });
+
+  it('should repeat the word correctly', () => {
+    const text = 'hello';
+    const repeatAmount = '3';
+    const result = repeatText({ ...initialValues, repeatAmount }, text);
+    expect(result).toBe('hellohellohello');
+  });
+
+  it('should repeat the word with a space delimiter correctly', () => {
+    const text = 'word';
+    const repeatAmount = '3';
+    const delimiter = ' ';
+    const result = repeatText(
+      { ...initialValues, repeatAmount, delimiter },
+      text
+    );
+    expect(result).toBe('word word word');
+  });
+
+  it('should repeat the word with a space and a comma delimiter correctly', () => {
+    const text = 'test';
+    const repeatAmount = '3';
+    const delimiter = ', ';
+    const result = repeatText(
+      { ...initialValues, repeatAmount, delimiter },
+      text
+    );
+    expect(result).toBe('test, test, test');
+  });
+
+  it('Should not repeat text if repeatAmount is zero', () => {
+    const text = 'something';
+    const repeatAmount = '0';
+    const result = repeatText({ ...initialValues, repeatAmount }, text);
+    expect(result).toBe('');
+  });
+
+  it('Should not repeat text if repeatAmount is not entered', () => {
+    const text = 'something';
+    const repeatAmount = '';
+    const result = repeatText({ ...initialValues, repeatAmount }, text);
+    expect(result).toBe('');
+  });
+});

src/pages/tools/string/repeat/service.ts

@@ -0,0 +1,9 @@
+import { InitialValuesType } from './initialValues';
+
+export function repeatText(options: InitialValuesType, text: string) {
+  const { repeatAmount, delimiter } = options;
+
+  const parsedAmount = parseInt(repeatAmount) || 0;
+
+  return Array(parsedAmount).fill(text).join(delimiter);
+}

src/pages/tools/string/rot13/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 Rot13() {
+  return <Box>Lorem ipsum</Box>;
+}

src/pages/tools/string/rot13/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: 'Rot13',
+  path: 'rot13',
+  icon: 'hugeicons:encrypt',
+  description: '',
+  shortDescription: '',
+  keywords: ['rot13'],
+  component: lazy(() => import('./index'))
+});

src/pages/tools/string/rot13/rot13.service.test.ts

@@ -0,0 +1,58 @@
+import { expect, describe, it } from 'vitest';
+import { rot13 } from './service';
+
+describe('rot13', () => {
+  it('should encode a simple string using ROT13', () => {
+    const input = 'hello';
+    const result = rot13(input);
+    expect(result).toBe('uryyb');
+  });
+
+  it('should decode a ROT13 encoded string', () => {
+    const input = 'uryyb';
+    const result = rot13(input);
+    expect(result).toBe('hello');
+  });
+
+  it('should handle uppercase letters correctly', () => {
+    const input = 'HELLO';
+    const result = rot13(input);
+    expect(result).toBe('URYYB');
+  });
+
+  it('should handle mixed case letters correctly', () => {
+    const input = 'HelloWorld';
+    const result = rot13(input);
+    expect(result).toBe('UryybJbeyq');
+  });
+
+  it('should handle non-alphabetic characters correctly', () => {
+    const input = 'Hello, World!';
+    const result = rot13(input);
+    expect(result).toBe('Uryyb, Jbeyq!');
+  });
+
+  it('should handle an empty string', () => {
+    const input = '';
+    const result = rot13(input);
+    expect(result).toBe('');
+  });
+
+  it('should handle a string with numbers correctly', () => {
+    const input = '1234';
+    const result = rot13(input);
+    expect(result).toBe('1234');
+  });
+
+  it('should handle a string with symbols correctly', () => {
+    const input = '!@#$%^&*()_+-=';
+    const result = rot13(input);
+    expect(result).toBe('!@#$%^&*()_+-=');
+  });
+
+  it('should handle a string with mixed characters correctly', () => {
+    const input = 'Hello, World! 123';
+    const result = rot13(input);
+    expect(result).toBe('Uryyb, Jbeyq! 123');
+  });
+});

src/pages/tools/string/rot13/service.ts

@@ -0,0 +1,7 @@
+export function rot13(input: string): string {
+  return input.replace(/[a-zA-Z]/g, (char) => {
+    const charCode = char.charCodeAt(0);
+    const baseCode = charCode >= 97 ? 97 : 65; // 'a' or 'A'
+    return String.fromCharCode(((charCode - baseCode + 13) % 26) + baseCode);
+  });
+}

src/pages/tools/string/rotate/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 Rotate() {
+  return <Box>Lorem ipsum</Box>;
+}

src/pages/tools/string/rotate/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: 'Rotate',
+  path: 'rotate',
+  icon: 'carbon:rotate',
+  description: '',
+  shortDescription: '',
+  keywords: ['rotate'],
+  component: lazy(() => import('./index'))
+});

src/pages/tools/string/rotate/rotate.service.test.ts

@@ -0,0 +1,69 @@
+import { expect, describe, it } from 'vitest';
+
+import { rotate, rotateString } from './service'; // Adjust the import path as necessary
+
+describe('rotate function', () => {
+  it('rotates right correctly', () => {
+    expect(rotate('abcdef', 2, true)).toBe('efabcd');
+    expect(rotate('abcdef', 1, true)).toBe('fabcde');
+    expect(rotate('abcdef', 6, true)).toBe('abcdef'); // full rotation
+    expect(rotate('abcdef', 7, true)).toBe('fabcde'); // beyond full rotation
+  });
+
+  it('rotates left correctly', () => {
+    expect(rotate('abcdef', 2, false)).toBe('cdefab');
+    expect(rotate('abcdef', 1, false)).toBe('bcdefa');
+    expect(rotate('abcdef', 6, false)).toBe('abcdef'); // full rotation
+    expect(rotate('abcdef', 7, false)).toBe('bcdefa'); // beyond full rotation
+  });
+
+  it('handles empty string', () => {
+    expect(rotate('', 2, true)).toBe('');
+    expect(rotate('', 2, false)).toBe('');
+  });
+
+  it('handles single character string', () => {
+    expect(rotate('a', 2, true)).toBe('a');
+    expect(rotate('a', 2, false)).toBe('a');
+  });
+});
+
+describe('rotateString function', () => {
+  it('rotates single-line string right', () => {
+    expect(rotateString('abcdef', 2, true, false)).toBe('efabcd');
+  });
+
+  it('rotates single-line string left', () => {
+    expect(rotateString('abcdef', 2, false, false)).toBe('cdefab');
+  });
+
+  it('rotates multi-line string right', () => {
+    const input = 'abcdef\nghijkl';
+    const expected = 'efabcd\nklghij';
+    expect(rotateString(input, 2, true, true)).toBe(expected);
+  });
+
+  it('rotates multi-line string left', () => {
+    const input = 'abcdef\nghijkl';
+    const expected = 'cdefab\nijklgh';
+    expect(rotateString(input, 2, false, true)).toBe(expected);
+  });
+
+  it('handles empty string in multi-line mode', () => {
+    expect(rotateString('', 2, true, true)).toBe('');
+  });
+
+  it('handles single character string in multi-line mode', () => {
+    expect(rotateString('a', 2, true, true)).toBe('a');
+  });
+
+  it('handles single character string in single-line mode', () => {
+    expect(rotateString('a', 2, true, false)).toBe('a');
+  });
+
+  it('handles string with multiple empty lines', () => {
+    const input = 'abcdef\n\nxyz';
+    const expected = 'efabcd\n\nyzx';
+    expect(rotateString(input, 2, true, true)).toBe(expected);
+  });
+});

src/pages/tools/string/rotate/service.ts

@@ -0,0 +1,43 @@
+export function rotate(input: string, step: number, right: boolean): string {
+  const array: string[] = input.split('');
+  const length = array.length;
+
+  if (length === 0) {
+    return input; // Return early if the input is an empty string
+  }
+
+  // Normalize the step to be within the bounds of the array length
+  const normalizedPositions = ((step % length) + length) % length;
+
+  if (right) {
+    // Rotate right
+    return array
+      .slice(-normalizedPositions)
+      .concat(array.slice(0, -normalizedPositions))
+      .join('');
+  } else {
+    // Rotate left
+    return array
+      .slice(normalizedPositions)
+      .concat(array.slice(0, normalizedPositions))
+      .join('');
+  }
+}
+
+export function rotateString(
+  input: string,
+  step: number,
+  right: boolean,
+  multiLine: boolean
+) {
+  const result: string[] = [];
+  if (multiLine) {
+    const array: string[] = input.split('\n');
+    for (const word of array) {
+      result.push(rotate(word, step, right));
+    }
+  } else {
+    result.push(rotate(input, step, right));
+  }
+  return result.join('\n');
+}