@pcg/text-kit 1.0.0-alpha.0

package/src/cases.ts

@@ -0,0 +1,317 @@
+import * as cc from 'change-case';
+import { default as cyrillicToTranslit } from 'cyrillic-to-translit-js';
+import { createRandomAbbreviationString } from './generators.js';
+
+/**
+ * Convert a string to string with the first character in uppercase.
+ * @example
+ * ucfirst('hello world'); // Hello world
+**/
+export const ucfirst = (input: string) => {
+  return input.charAt(0).toUpperCase() + input.substring(1);
+};
+
+/**
+ * Convert a string to string with the first character in lower case.
+ * @example
+ * lcfirst('Hello world'); // hello world
+ **/
+export const lcfirst = (input: string) => {
+  return input.charAt(0).toLowerCase() + input.substring(1);
+};
+
+/**
+ * Convert a string to PascalCase.
+ * @example
+ * pascalCase('foo bar'); //=> 'FooBar'
+ * pascalCase('foo_bar'); //=> 'FooBar'
+ * pascalCase('foo-bar'); //=> 'FooBar'
+ * pascalCase('foo.bar'); //=> 'FooBar'
+ * pascalCase('fooBar'); //=> 'FooBar'
+**/
+export const pascalCase = (input: string) => {
+  return cc.pascalCase(input, {
+    mergeAmbiguousCharacters: true,
+  });
+};
+
+/**
+ * Convert a string to camelCase.
+ * @example
+ * camelCase('foo bar'); //=> 'fooBar'
+ * camelCase('foo_bar'); //=> 'fooBar'
+ * camelCase('foo-bar'); //=> 'fooBar'
+ * camelCase('foo.bar'); //=> 'fooBar'
+ * camelCase('fooBar'); //=> 'fooBar'
+ * camelCase('FooBar'); //=> 'fooBar'
+**/
+export const camelCase = (input: string) => {
+  return cc.camelCase(input);
+};
+
+/**
+ * Convert a string to param-case.
+ * @example
+ * paramCase('foo bar'); //=> 'foo-bar'
+ * paramCase('foo_bar'); //=> 'foo-bar'
+ * paramCase('foo-bar'); //=> 'foo-bar'
+ * paramCase('foo.bar'); //=> 'foo-bar'
+ * paramCase('fooBar'); //=> 'foo-bar'
+ * paramCase('FooBar'); //=> 'foo-bar'
+**/
+export const paramCase = (input: string) => {
+  return cc.kebabCase(input);
+};
+
+/**
+ * Convert a string to "dot.case".
+ * @example
+ * dotCase('foo bar'); //=> 'foo.bar'
+ * dotCase('foo_bar'); //=> 'foo.bar'
+ * dotCase('foo-bar'); //=> 'foo.bar'
+ * dotCase('foo.bar'); //=> 'foo.bar'
+ * dotCase('fooBar'); //=> 'foo.bar'
+ * dotCase('FooBar'); //=> 'foo.bar'
+**/
+export const dotCase = (input: string) => {
+  return cc.dotCase(input);
+};
+
+/**
+ * Convert a string to snake_case.
+ * @example
+ * snakeCase('foo bar'); //=> 'foo_bar'
+ * snakeCase('foo_bar'); //=> 'foo_bar'
+ * snakeCase('foo-bar'); //=> 'foo_bar'
+ * snakeCase('foo.bar'); //=> 'foo_bar'
+ * snakeCase('fooBar'); //=> 'foo_bar'
+ * snakeCase('FooBar'); //=> 'foo_bar'
+**/
+export const snakeCase = (input: string) => {
+  return cc.snakeCase(input);
+};
+
+/**
+ * Convert a string to CONSTANT_CASE.
+ * @example
+ * constantCase('foo bar'); //=> 'FOO_BAR'
+ * constantCase('foo_bar'); //=> 'FOO_BAR'
+ * constantCase('foo-bar'); //=> 'FOO_BAR'
+ * constantCase('foo.bar'); //=> 'FOO_BAR'
+ * constantCase('fooBar'); //=> 'FOO_BAR'
+ * constantCase('FooBar'); //=> 'FOO_BAR'
+**/
+export const constantCase = (input: string) => {
+  return cc.constantCase(input);
+};
+
+/**
+ * Convert a string to sentence.
+ * @deprecated use sentenceCase instead
+ * @example
+ * toSentence('foo bar'); //=> 'Foo bar'
+ * toSentence('foo_bar'); //=> 'Foo bar'
+ * toSentence('foo-bar'); //=> 'Foo bar'
+ * toSentence('foo.bar'); //=> 'Foo bar'
+ * toSentence('fooBar'); //=> 'Foo bar'
+ * toSentence('FooBar'); //=> 'Foo bar'
+ * toSentence('foo bar baz'); //=> 'Foo bar baz'
+**/
+export const toSentence = (input: string) => {
+  return ucfirst(cc.noCase(input, {
+    delimiter: ' ',
+  }));
+};
+
+/**
+ * Convert a string to sentence.
+ * @example
+ * sentenceCase('foo bar'); //=> 'Foo bar'
+ * sentenceCase('foo_bar'); //=> 'Foo bar'
+ * sentenceCase('foo-bar'); //=> 'Foo bar'
+ * sentenceCase('foo.bar'); //=> 'Foo bar'
+ * sentenceCase('fooBar'); //=> 'Foo bar'
+ * sentenceCase('FooBar'); //=> 'Foo bar'
+ * sentenceCase('foo bar baz'); //=> 'Foo bar baz'
+**/
+export const sentenceCase = (input: string) => {
+  return cc.sentenceCase(input);
+};
+
+/**
+ * Convert a string to upper cased sentence.
+ * @deprecated use capitalCase instead
+ * @example
+ * toUcSentence('foo bar'); //=> 'Foo Bar'
+ * toUcSentence('foo_bar'); //=> 'Foo Bar'
+ * toUcSentence('foo-bar'); //=> 'Foo Bar'
+ * toUcSentence('foo.bar'); //=> 'Foo Bar'
+ * toUcSentence('fooBar'); //=> 'Foo Bar'
+ * toUcSentence('FooBar'); //=> 'Foo Bar'
+ * toUcSentence('foo bar baz'); //=> 'Foo Bar Baz'
+**/
+export const toUcSentence = (input: string) => {
+  return cc.capitalCase(input);
+};
+
+/**
+ * Convert a string to upper cased sentence.
+ * @example
+ * capitalCase('foo bar'); //=> 'Foo Bar'
+ * capitalCase('foo_bar'); //=> 'Foo Bar'
+ * capitalCase('foo-bar'); //=> 'Foo Bar'
+ * capitalCase('foo.bar'); //=> 'Foo Bar'
+ * capitalCase('fooBar'); //=> 'Foo Bar'
+ * capitalCase('FooBar'); //=> 'Foo Bar'
+ * capitalCase('foo bar baz'); //=> 'Foo Bar Baz'
+**/
+export const capitalCase = (input: string) => {
+  return cc.capitalCase(input);
+};
+
+/**
+ * Alias to "toUcSentence"
+ * @deprecated use capitalCase instead
+**/
+export const capitalize = (input: string) => toUcSentence(input);
+
+/**
+ * Convert a string to lower cased sentence.
+ * @deprecated use lowerSentenceCase instead
+ * @example
+ * toLcSentence('foo bar'); //=> 'foo bar'
+ * toLcSentence('foo_bar'); //=> 'foo bar'
+ * toLcSentence('foo-bar'); //=> 'foo bar'
+ * toLcSentence('foo.bar'); //=> 'foo bar'
+ * toLcSentence('fooBar'); //=> 'foo bar'
+ * toLcSentence('FooBar'); //=> 'foo bar'
+ * toLcSentence('Foo bar baz'); //=> 'foo bar baz'
+**/
+export const toLcSentence = (input: string) => {
+  return sentenceCase(input).toLowerCase();
+};
+
+/**
+ * Convert a string to lower cased sentence.
+ * @example
+ * lowerSentenceCase('foo bar'); //=> 'foo bar'
+ * lowerSentenceCase('foo_bar'); //=> 'foo bar'
+ * lowerSentenceCase('foo-bar'); //=> 'foo bar'
+ * lowerSentenceCase('foo.bar'); //=> 'foo bar'
+ * lowerSentenceCase('fooBar'); //=> 'foo bar'
+ * lowerSentenceCase('FooBar'); //=> 'foo bar'
+ * lowerSentenceCase('Foo bar baz'); //=> 'foo bar baz'
+**/
+export const lowerSentenceCase = (input: string) => {
+  return sentenceCase(input).toLowerCase();
+};
+
+/**
+ * Convert a table name to sql alias.
+ * @example
+ * toSqlAlias('foo bar'); //=> 'fb'
+ * toSqlAlias('book'); //=> 'b'
+ * toSqlAlias('article-category'); //=> 'ac'
+**/
+export const toSqlAlias = (input: string): string => {
+  return snakeCase(input)
+    .split('_')
+    .reduce((acc, word) => acc.concat(word[0]), '');
+};
+
+export interface ToAbbreviationOptions {
+  maxLength?: number;
+  minLength?: number;
+  lang?: 'uk' | 'ru' | 'mn';
+  iteration?: number;
+}
+
+/**
+ * Remove vowels from a word.
+ * @param word - word to remove vowels from
+ * @returns word without vowels
+ * @example
+ * removeVowels('foo'); //=> 'f'
+ */
+export const removeVowels = (word: string) => {
+  return word.replace(/[aeiou]/gi, '');
+};
+
+/**
+ * Convert a string to abbreviation.
+ * @example
+ * toAbbreviation('Sabbath Schook'); //=> 'SB'
+ * toAbbreviation('Рожеві окуляри', {
+ *  lang: 'uk',
+ * }); //=> 'RO'
+ * toAbbreviation('Удивительные факты', {
+ *  lang: 'ru',
+ * }); //=> 'UF'
+ */
+export const toAbbreviation = (input: string, opts?: ToAbbreviationOptions): string => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const transliterator = (cyrillicToTranslit as any)(opts?.lang ? {
+    preset: opts.lang,
+  } : undefined);
+
+  const words = transliterator
+    .transform(input)
+    .toUpperCase()
+    .replace(/[^A-Z ]/g, '')
+    .split(' ')
+    .filter((word: string) => word.length > 0);
+
+  // .map((word) =>).toUpperCase());
+
+  let abbreviation = '';
+
+  // Sabbath School => SS
+  if (words.length > 1) {
+    abbreviation = words.reduce((acc: string, word: string) => {
+      if (word.length >= 1) {
+        acc += word[0];
+      }
+
+      return acc;
+    }, '');
+  } else if (words.length === 1) {
+    const word = words[0];
+
+    // Sabbath => SBBTH
+    if (word.length > 1) {
+      abbreviation = word.slice(0, 1) + removeVowels(word.slice(1));
+    } else {
+      abbreviation = word;
+    }
+  }
+
+  // If the maxLength option is set, trim the abbreviation before adding random characters and appending digits
+  if (opts?.maxLength && !opts?.iteration) {
+    abbreviation = abbreviation.slice(0, opts.maxLength);
+  }
+
+  // If the minLength option is set, ensure the abbreviation meets the minimum length by appending random characters before appending digits
+  if (opts?.minLength && abbreviation.length < opts.minLength) {
+    let charsNeeded = opts.minLength - abbreviation.length;
+    if (opts?.iteration && opts?.iteration > 0) {
+      charsNeeded -= 1;
+    }
+
+    if (charsNeeded > 0) {
+      abbreviation += createRandomAbbreviationString(charsNeeded).toUpperCase();
+    }
+  }
+
+  // Append a number based on the iteration option
+  if (opts?.iteration) {
+    if (opts?.maxLength) {
+      // Calculate the maximum length the abbreviation can be, considering the digits and random characters
+      const maxAbbrLength = opts.maxLength - 1;
+      abbreviation = abbreviation.slice(0, maxAbbrLength);
+    }
+
+    abbreviation += opts.iteration;
+  }
+
+  return abbreviation;
+};

package/src/declination.ts

@@ -0,0 +1,23 @@
+/**
+ * Decline a noun based on a number.
+ * @example
+ * const words = ['элемент', 'элемента', 'элементов'];
+ *
+ * decline(0, words, false) // => 'элементов'
+ * decline(24, words, false) // => 'элемента'
+ * decline(21, words, false) // => 'элемент'
+ *
+ * decline(0, words) // => '0 элементов'
+ * decline(24, words) // => '24 элемента'
+ * decline(21, words) // => '21 элемент'
+ */
+export const decline = (n: number, words: string[], concat = true) => {
+  const word =
+    words[
+      n % 100 > 4 && n % 100 < 20
+        ? 2
+        : [2, 0, 1, 1, 1, 2][n % 10 < 5 ? n % 10 : 5]
+    ];
+
+  return concat ? `${n} ${word}` : word;
+};

package/src/entities.ts

@@ -0,0 +1,41 @@
+import { camelCase, pascalCase } from './cases.js';
+import { singularToPlural } from './pluralize.js';
+
+/**
+  Returns variations of entity type names
+
+  @example
+| entityType                 | 'CodePuzzle'          |
+|----------------------------|-----------------------|
+| pascalCaseEntityType       | 'CodePuzzle'          |
+| camelCaseEntityType        | 'CodePuzzle'          |
+| pluralEntityType           | 'CodePuzzles'         |
+| pluralCamelCaseEntityType  | 'codePuzzles'         |
+| pluralPascalCaseEntityType | 'CodePuzzles'         |
+| createMutationName         | 'createCodePuzzle'    |
+| updateMutationName         | 'updateCodePuzzle'    |
+| deleteMutationName         | 'deleteCodePuzzle'    |
+| dublicateMutationName      | 'dublicateCodePuzzle' |
+| publishMutationName        | 'publishCodePuzzle'   |
+*/
+export const createEntityTypeNames = (entityType: string) => {
+  const pluralEntityType = singularToPlural(entityType); // codepuzzles
+  const camelCaseEntityType = camelCase(entityType); // codepuzzle
+  const pascalCaseEntityType = pascalCase(entityType); // CodePuzzle
+
+  const pluralPascalCaseEntityType = pascalCase(pluralEntityType); // CodePuzzles
+
+  return {
+    pluralEntityType,
+    camelCaseEntityType,
+    pascalCaseEntityType,
+    pluralCamelCaseEntityType: camelCase(pluralEntityType),
+    pluralPascalCaseEntityType,
+    createMutationName: `create${pascalCaseEntityType}`,
+    updateMutationName: `update${pascalCaseEntityType}`,
+    deleteMutationName: `delete${pascalCaseEntityType}`,
+    dublicateMutationName: `dublicate${pascalCaseEntityType}`,
+    publishMutationName: `publish${pascalCaseEntityType}`,
+    unpublishMutationName: `unpublish${pascalCaseEntityType}`,
+  };
+};

package/src/generators.ts

@@ -0,0 +1,16 @@
+import { customAlphabet } from 'nanoid/non-secure';
+
+export const createRandomString = (size = 8) => {
+  return customAlphabet('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', size)();
+};
+
+export const createRandomAbbreviationString = (size = 8) => {
+  return customAlphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ', size)();
+};
+
+export const createNumericCode = (num: number, length: number): string => {
+  // Add leading zeros if necessary using padStart
+  const numberStr = num.toString().padStart(length, '0');
+
+  return numberStr;
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './cases.js';
+export * from './declination.js';
+export * from './generators.js';
+export * from './pluralize.js';
+

package/src/pluralize.ts

@@ -0,0 +1,35 @@
+import * as pluralize from 'pluralize';
+
+/**
+ * Change the plural form of a word to its singular form.
+ * @example
+ * pluralToSingular('books'); //=> 'book'
+ */
+export const singularToPlural = (input: string): string => {
+  return pluralize.plural(input);
+};
+
+/**
+ * Change the singular form of a word to its plural form.
+ * @example
+ * singularToPlural('book'); //=> 'books'
+ */
+export const pluralToSingular = (input: string): string => {
+  return pluralize.singular(input);
+};
+
+/**
+ * Checks if a given word is in its plural form.
+ *
+ * @param word - The word to check for plural form
+ * @returns `true` if the word is plural, `false` if it's singular
+ *
+ * @example
+ * ```typescript
+ * isPlural("cats"); // true
+ * isPlural("cat");  // false
+ * ```
+ */
+export const isPlural = (word: string): boolean =>
+  singularToPlural(word) === word;
+

package/tests/cases.test.ts

@@ -0,0 +1,196 @@
+import {
+  describe, expect, test,
+} from 'vitest';
+
+import {
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  lcfirst,
+  lowerSentenceCase,
+  paramCase,
+  pascalCase,
+  sentenceCase,
+  snakeCase,
+  toAbbreviation,
+  ToAbbreviationOptions,
+  toSqlAlias,
+  ucfirst,
+} from '../src/cases.js';
+
+describe('Cases', () => {
+  test('ucfirst', () => {
+    expect(ucfirst('simple')).toBe('Simple');
+    expect(ucfirst('S')).toBe('S');
+  });
+
+  test('lcfirst', () => {
+    expect(lcfirst('Simple')).toBe('simple');
+  });
+
+  test('camelCase', () => {
+    expect(camelCase('simple')).toBe('simple');
+    expect(camelCase('some.dot.case')).toBe('someDotCase');
+    expect(camelCase('some-param-case')).toBe('someParamCase');
+    expect(camelCase('some_param_case')).toBe('someParamCase');
+    expect(camelCase('SOME_PARAM_CASE')).toBe('someParamCase');
+    expect(camelCase('some spaced case')).toBe('someSpacedCase');
+    expect(camelCase('someCamelCase')).toBe('someCamelCase');
+    expect(camelCase('SomePascalCase')).toBe('somePascalCase');
+  });
+
+  test('pascalCase', () => {
+    expect(pascalCase('simple')).toBe('Simple');
+    expect(pascalCase('some.dot.case')).toBe('SomeDotCase');
+    expect(pascalCase('some-param-case')).toBe('SomeParamCase');
+    expect(pascalCase('some spaced case')).toBe('SomeSpacedCase');
+    expect(pascalCase('someCamelCase')).toBe('SomeCamelCase');
+    expect(pascalCase('SomePascalCase')).toBe('SomePascalCase');
+    expect(pascalCase('upload-2')).toBe('Upload2');
+  });
+
+  test('paramCase', () => {
+    expect(paramCase('simple')).toBe('simple');
+    expect(paramCase('some.dot.case')).toBe('some-dot-case');
+    expect(paramCase('some-param-case')).toBe('some-param-case');
+    expect(paramCase('some spaced case')).toBe('some-spaced-case');
+    expect(paramCase('someCamelCase')).toBe('some-camel-case');
+    expect(paramCase('SomePascalCase')).toBe('some-pascal-case');
+  });
+
+  test('dotCase', () => {
+    expect(dotCase('simple')).toBe('simple');
+    expect(dotCase('some.dot.case')).toBe('some.dot.case');
+    expect(dotCase('some-param-case')).toBe('some.param.case');
+    expect(dotCase('some spaced case')).toBe('some.spaced.case');
+    expect(dotCase('someCamelCase')).toBe('some.camel.case');
+    expect(dotCase('SomePascalCase')).toBe('some.pascal.case');
+  });
+
+  test('snakeCase', () => {
+    expect(snakeCase('simple')).toBe('simple');
+    expect(snakeCase('some.dot.case')).toBe('some_dot_case');
+    expect(snakeCase('some-param-case')).toBe('some_param_case');
+    expect(snakeCase('some spaced case')).toBe('some_spaced_case');
+    expect(snakeCase('someCamelCase')).toBe('some_camel_case');
+    expect(snakeCase('SomePascalCase')).toBe('some_pascal_case');
+  });
+
+  test('constantCase', () => {
+    expect(constantCase('maxValue')).toBe('MAX_VALUE');
+    expect(constantCase('mp4-720')).toBe('MP4_720');
+    expect(constantCase('QUALITY_4K')).toBe('QUALITY_4_K');
+  });
+
+  test('sentenceCase', () => {
+    expect(sentenceCase('simple')).toBe('Simple');
+    expect(sentenceCase('some.dot.case')).toBe('Some dot case');
+    expect(sentenceCase('some-param-case')).toBe('Some param case');
+    expect(sentenceCase('some spaced case')).toBe('Some spaced case');
+    expect(sentenceCase('someCamelCase')).toBe('Some camel case');
+    expect(sentenceCase('SomePascalCase')).toBe('Some pascal case');
+  });
+
+  test('capitalCase', () => {
+    expect(capitalCase('simple')).toBe('Simple');
+    expect(capitalCase('some.dot.case')).toBe('Some Dot Case');
+    expect(capitalCase('some-param-case')).toBe('Some Param Case');
+    expect(capitalCase('some spaced case')).toBe('Some Spaced Case');
+    expect(capitalCase('someCamelCase')).toBe('Some Camel Case');
+    expect(capitalCase('SomePascalCase')).toBe('Some Pascal Case');
+  });
+
+  test('lowerSentenceCase', () => {
+    expect(lowerSentenceCase('simple')).toBe('simple');
+    expect(lowerSentenceCase('some.dot.case')).toBe('some dot case');
+    expect(lowerSentenceCase('some-param-case')).toBe('some param case');
+    expect(lowerSentenceCase('some spaced case')).toBe('some spaced case');
+    expect(lowerSentenceCase('someCamelCase')).toBe('some camel case');
+    expect(lowerSentenceCase('SomePascalCase')).toBe('some pascal case');
+  });
+
+  test('toSqlAlias', () => {
+    expect(toSqlAlias('foo bar')).toBe('fb');
+    expect(toSqlAlias('book')).toBe('b');
+    expect(toSqlAlias('article-category')).toBe('ac');
+  });
+
+  test.each<[string, string, ToAbbreviationOptions]>([
+    ['Sabbath', 'SBBTH', {
+    }],
+    ['Sabbath', 'SB', {
+      maxLength: 2,
+    }],
+    ['Sabbath School', 'SS', {
+    }],
+    ['Sabbath && (School)', 'SS', {
+    }],
+    ['Рожеві окуляри', 'RO', {
+      lang: 'uk',
+    }],
+    ['Удивительные факты', 'UF', {
+      lang: 'ru',
+    }],
+    [`Very long title but i dont know why, maybe because i can't stop write this title`, 'VLTBI', {
+      maxLength: 5,
+    }],
+    ['Sabbath School', 'SS', {
+      maxLength: 5,
+      iteration: 0,
+    }],
+    ['Sabbath School', 'SS1', {
+      maxLength: 5,
+      iteration: 1,
+    }],
+    ['Sabbath', 'SBBTH', {
+      maxLength: 5,
+      iteration: 0,
+    }],
+    ['Sabbath', 'SBBT1', {
+      maxLength: 5,
+      iteration: 1,
+    }],
+  ])('toAbbreviation(%s) = %s (%j)', (
+    abbreviation: string,
+    expected: string,
+    opts: ToAbbreviationOptions,
+  ) => {
+    expect(toAbbreviation(abbreviation, opts)).toBe(expected);
+  });
+
+  test.each<[string, number, ToAbbreviationOptions]>([
+    ['Some text', 3, {
+      maxLength: 5,
+      minLength: 3,
+    }],
+    ['Sabbath School', 6, {
+      maxLength: 6,
+      minLength: 6,
+    }],
+    ['0_o', 3, {
+      maxLength: 5,
+      minLength: 3,
+      iteration: 1,
+    }],
+    ['S4', 3, {
+      maxLength: 5,
+      minLength: 3,
+      iteration: 1,
+    }],
+    ['333', 3, {
+      maxLength: 5,
+      minLength: 3,
+      iteration: 1,
+    }],
+  ])('toAbbreviation with random strings: toAbbreviation(%s).length => %s (%j)', (
+    abbreviation,
+    expectedLenght,
+    opts,
+  ) => {
+    const result = toAbbreviation(abbreviation, opts);
+    // console.log(abbreviation, result);
+
+    expect(result.length).toBe(expectedLenght);
+  });
+});

package/tests/declination.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'vitest';
+
+import { decline } from '../src/declination.js';
+const words = ['элемент', 'элемента', 'элементов'];
+
+test('must decline word', () => {
+  expect(decline(0, words, false)).toBe('элементов');
+  expect(decline(24, words, false)).toBe('элемента');
+  expect(decline(21, words, false)).toBe('элемент');
+
+  expect(decline(0, words)).toBe('0 элементов');
+  expect(decline(24, words)).toBe('24 элемента');
+  expect(decline(21, words)).toBe('21 элемент');
+});