@pcg/text-kit 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,324 @@
+import * as cc from "change-case";
+import cyrillicToTranslit from "cyrillic-to-translit-js";
+import { customAlphabet } from "nanoid/non-secure";
+import * as pluralize from "pluralize";
+
+//#region src/generators.ts
+const createRandomString = (size = 8) => {
+	return customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", size)();
+};
+const createRandomAbbreviationString = (size = 8) => {
+	return customAlphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ", size)();
+};
+const createNumericCode = (num, length) => {
+	return num.toString().padStart(length, "0");
+};
+
+//#endregion
+//#region src/cases.ts
+/**
+* Convert a string to string with the first character in uppercase.
+* @example
+* ucfirst('hello world'); // Hello world
+**/
+const ucfirst = (input) => {
+	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
+**/
+const lcfirst = (input) => {
+	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'
+**/
+const pascalCase = (input) => {
+	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'
+**/
+const camelCase = (input) => {
+	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'
+**/
+const paramCase = (input) => {
+	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'
+**/
+const dotCase = (input) => {
+	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'
+**/
+const snakeCase = (input) => {
+	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'
+**/
+const constantCase = (input) => {
+	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'
+**/
+const toSentence = (input) => {
+	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'
+**/
+const sentenceCase = (input) => {
+	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'
+**/
+const toUcSentence = (input) => {
+	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'
+**/
+const capitalCase = (input) => {
+	return cc.capitalCase(input);
+};
+/**
+* Alias to "toUcSentence"
+* @deprecated use capitalCase instead
+**/
+const capitalize = (input) => 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'
+**/
+const toLcSentence = (input) => {
+	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'
+**/
+const lowerSentenceCase = (input) => {
+	return sentenceCase(input).toLowerCase();
+};
+/**
+* Convert a table name to sql alias.
+* @example
+* toSqlAlias('foo bar'); //=> 'fb'
+* toSqlAlias('book'); //=> 'b'
+* toSqlAlias('article-category'); //=> 'ac'
+**/
+const toSqlAlias = (input) => {
+	return snakeCase(input).split("_").reduce((acc, word) => acc.concat(word[0]), "");
+};
+/**
+* Remove vowels from a word.
+* @param word - word to remove vowels from
+* @returns word without vowels
+* @example
+* removeVowels('foo'); //=> 'f'
+*/
+const removeVowels = (word) => {
+	return word.replace(/[aeiou]/gi, "");
+};
+/**
+* Convert a string to abbreviation.
+* @example
+* toAbbreviation('Sabbath Schook'); //=> 'SB'
+* toAbbreviation('Рожеві окуляри', {
+*  lang: 'uk',
+* }); //=> 'RO'
+* toAbbreviation('Удивительные факты', {
+*  lang: 'ru',
+* }); //=> 'UF'
+*/
+const toAbbreviation = (input, opts) => {
+	const words = cyrillicToTranslit(opts?.lang ? { preset: opts.lang } : void 0).transform(input).toUpperCase().replace(/[^A-Z ]/g, "").split(" ").filter((word) => word.length > 0);
+	let abbreviation = "";
+	if (words.length > 1) abbreviation = words.reduce((acc, word) => {
+		if (word.length >= 1) acc += word[0];
+		return acc;
+	}, "");
+	else if (words.length === 1) {
+		const word = words[0];
+		if (word.length > 1) abbreviation = word.slice(0, 1) + removeVowels(word.slice(1));
+		else abbreviation = word;
+	}
+	if (opts?.maxLength && !opts?.iteration) abbreviation = abbreviation.slice(0, opts.maxLength);
+	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();
+	}
+	if (opts?.iteration) {
+		if (opts?.maxLength) {
+			const maxAbbrLength = opts.maxLength - 1;
+			abbreviation = abbreviation.slice(0, maxAbbrLength);
+		}
+		abbreviation += opts.iteration;
+	}
+	return abbreviation;
+};
+
+//#endregion
+//#region src/declination.ts
+/**
+* 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 элемент'
+*/
+const decline = (n, words, 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;
+};
+
+//#endregion
+//#region src/pluralize.ts
+/**
+* Change the plural form of a word to its singular form.
+* @example
+* pluralToSingular('books'); //=> 'book'
+*/
+const singularToPlural = (input) => {
+	return pluralize.plural(input);
+};
+/**
+* Change the singular form of a word to its plural form.
+* @example
+* singularToPlural('book'); //=> 'books'
+*/
+const pluralToSingular = (input) => {
+	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
+* ```
+*/
+const isPlural = (word) => singularToPlural(word) === word;
+
+//#endregion
+export { camelCase, capitalCase, capitalize, constantCase, createNumericCode, createRandomAbbreviationString, createRandomString, decline, dotCase, isPlural, lcfirst, lowerSentenceCase, paramCase, pascalCase, pluralToSingular, removeVowels, sentenceCase, singularToPlural, snakeCase, toAbbreviation, toLcSentence, toSentence, toSqlAlias, toUcSentence, ucfirst };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/generators.ts","../src/cases.ts","../src/declination.ts","../src/pluralize.ts"],"sourcesContent":["import { customAlphabet } from 'nanoid/non-secure';\n\nexport const createRandomString = (size = 8) => {\n  return customAlphabet('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', size)();\n};\n\nexport const createRandomAbbreviationString = (size = 8) => {\n  return customAlphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ', size)();\n};\n\nexport const createNumericCode = (num: number, length: number): string => {\n  // Add leading zeros if necessary using padStart\n  const numberStr = num.toString().padStart(length, '0');\n\n  return numberStr;\n};\n","import * as cc from 'change-case';\nimport { default as cyrillicToTranslit } from 'cyrillic-to-translit-js';\nimport { createRandomAbbreviationString } from './generators.js';\n\n/**\n * Convert a string to string with the first character in uppercase.\n * @example\n * ucfirst('hello world'); // Hello world\n**/\nexport const ucfirst = (input: string) => {\n  return input.charAt(0).toUpperCase() + input.substring(1);\n};\n\n/**\n * Convert a string to string with the first character in lower case.\n * @example\n * lcfirst('Hello world'); // hello world\n **/\nexport const lcfirst = (input: string) => {\n  return input.charAt(0).toLowerCase() + input.substring(1);\n};\n\n/**\n * Convert a string to PascalCase.\n * @example\n * pascalCase('foo bar'); //=> 'FooBar'\n * pascalCase('foo_bar'); //=> 'FooBar'\n * pascalCase('foo-bar'); //=> 'FooBar'\n * pascalCase('foo.bar'); //=> 'FooBar'\n * pascalCase('fooBar'); //=> 'FooBar'\n**/\nexport const pascalCase = (input: string) => {\n  return cc.pascalCase(input, {\n    mergeAmbiguousCharacters: true,\n  });\n};\n\n/**\n * Convert a string to camelCase.\n * @example\n * camelCase('foo bar'); //=> 'fooBar'\n * camelCase('foo_bar'); //=> 'fooBar'\n * camelCase('foo-bar'); //=> 'fooBar'\n * camelCase('foo.bar'); //=> 'fooBar'\n * camelCase('fooBar'); //=> 'fooBar'\n * camelCase('FooBar'); //=> 'fooBar'\n**/\nexport const camelCase = (input: string) => {\n  return cc.camelCase(input);\n};\n\n/**\n * Convert a string to param-case.\n * @example\n * paramCase('foo bar'); //=> 'foo-bar'\n * paramCase('foo_bar'); //=> 'foo-bar'\n * paramCase('foo-bar'); //=> 'foo-bar'\n * paramCase('foo.bar'); //=> 'foo-bar'\n * paramCase('fooBar'); //=> 'foo-bar'\n * paramCase('FooBar'); //=> 'foo-bar'\n**/\nexport const paramCase = (input: string) => {\n  return cc.kebabCase(input);\n};\n\n/**\n * Convert a string to \"dot.case\".\n * @example\n * dotCase('foo bar'); //=> 'foo.bar'\n * dotCase('foo_bar'); //=> 'foo.bar'\n * dotCase('foo-bar'); //=> 'foo.bar'\n * dotCase('foo.bar'); //=> 'foo.bar'\n * dotCase('fooBar'); //=> 'foo.bar'\n * dotCase('FooBar'); //=> 'foo.bar'\n**/\nexport const dotCase = (input: string) => {\n  return cc.dotCase(input);\n};\n\n/**\n * Convert a string to snake_case.\n * @example\n * snakeCase('foo bar'); //=> 'foo_bar'\n * snakeCase('foo_bar'); //=> 'foo_bar'\n * snakeCase('foo-bar'); //=> 'foo_bar'\n * snakeCase('foo.bar'); //=> 'foo_bar'\n * snakeCase('fooBar'); //=> 'foo_bar'\n * snakeCase('FooBar'); //=> 'foo_bar'\n**/\nexport const snakeCase = (input: string) => {\n  return cc.snakeCase(input);\n};\n\n/**\n * Convert a string to CONSTANT_CASE.\n * @example\n * constantCase('foo bar'); //=> 'FOO_BAR'\n * constantCase('foo_bar'); //=> 'FOO_BAR'\n * constantCase('foo-bar'); //=> 'FOO_BAR'\n * constantCase('foo.bar'); //=> 'FOO_BAR'\n * constantCase('fooBar'); //=> 'FOO_BAR'\n * constantCase('FooBar'); //=> 'FOO_BAR'\n**/\nexport const constantCase = (input: string) => {\n  return cc.constantCase(input);\n};\n\n/**\n * Convert a string to sentence.\n * @deprecated use sentenceCase instead\n * @example\n * toSentence('foo bar'); //=> 'Foo bar'\n * toSentence('foo_bar'); //=> 'Foo bar'\n * toSentence('foo-bar'); //=> 'Foo bar'\n * toSentence('foo.bar'); //=> 'Foo bar'\n * toSentence('fooBar'); //=> 'Foo bar'\n * toSentence('FooBar'); //=> 'Foo bar'\n * toSentence('foo bar baz'); //=> 'Foo bar baz'\n**/\nexport const toSentence = (input: string) => {\n  return ucfirst(cc.noCase(input, {\n    delimiter: ' ',\n  }));\n};\n\n/**\n * Convert a string to sentence.\n * @example\n * sentenceCase('foo bar'); //=> 'Foo bar'\n * sentenceCase('foo_bar'); //=> 'Foo bar'\n * sentenceCase('foo-bar'); //=> 'Foo bar'\n * sentenceCase('foo.bar'); //=> 'Foo bar'\n * sentenceCase('fooBar'); //=> 'Foo bar'\n * sentenceCase('FooBar'); //=> 'Foo bar'\n * sentenceCase('foo bar baz'); //=> 'Foo bar baz'\n**/\nexport const sentenceCase = (input: string) => {\n  return cc.sentenceCase(input);\n};\n\n/**\n * Convert a string to upper cased sentence.\n * @deprecated use capitalCase instead\n * @example\n * toUcSentence('foo bar'); //=> 'Foo Bar'\n * toUcSentence('foo_bar'); //=> 'Foo Bar'\n * toUcSentence('foo-bar'); //=> 'Foo Bar'\n * toUcSentence('foo.bar'); //=> 'Foo Bar'\n * toUcSentence('fooBar'); //=> 'Foo Bar'\n * toUcSentence('FooBar'); //=> 'Foo Bar'\n * toUcSentence('foo bar baz'); //=> 'Foo Bar Baz'\n**/\nexport const toUcSentence = (input: string) => {\n  return cc.capitalCase(input);\n};\n\n/**\n * Convert a string to upper cased sentence.\n * @example\n * capitalCase('foo bar'); //=> 'Foo Bar'\n * capitalCase('foo_bar'); //=> 'Foo Bar'\n * capitalCase('foo-bar'); //=> 'Foo Bar'\n * capitalCase('foo.bar'); //=> 'Foo Bar'\n * capitalCase('fooBar'); //=> 'Foo Bar'\n * capitalCase('FooBar'); //=> 'Foo Bar'\n * capitalCase('foo bar baz'); //=> 'Foo Bar Baz'\n**/\nexport const capitalCase = (input: string) => {\n  return cc.capitalCase(input);\n};\n\n/**\n * Alias to \"toUcSentence\"\n * @deprecated use capitalCase instead\n**/\nexport const capitalize = (input: string) => toUcSentence(input);\n\n/**\n * Convert a string to lower cased sentence.\n * @deprecated use lowerSentenceCase instead\n * @example\n * toLcSentence('foo bar'); //=> 'foo bar'\n * toLcSentence('foo_bar'); //=> 'foo bar'\n * toLcSentence('foo-bar'); //=> 'foo bar'\n * toLcSentence('foo.bar'); //=> 'foo bar'\n * toLcSentence('fooBar'); //=> 'foo bar'\n * toLcSentence('FooBar'); //=> 'foo bar'\n * toLcSentence('Foo bar baz'); //=> 'foo bar baz'\n**/\nexport const toLcSentence = (input: string) => {\n  return sentenceCase(input).toLowerCase();\n};\n\n/**\n * Convert a string to lower cased sentence.\n * @example\n * lowerSentenceCase('foo bar'); //=> 'foo bar'\n * lowerSentenceCase('foo_bar'); //=> 'foo bar'\n * lowerSentenceCase('foo-bar'); //=> 'foo bar'\n * lowerSentenceCase('foo.bar'); //=> 'foo bar'\n * lowerSentenceCase('fooBar'); //=> 'foo bar'\n * lowerSentenceCase('FooBar'); //=> 'foo bar'\n * lowerSentenceCase('Foo bar baz'); //=> 'foo bar baz'\n**/\nexport const lowerSentenceCase = (input: string) => {\n  return sentenceCase(input).toLowerCase();\n};\n\n/**\n * Convert a table name to sql alias.\n * @example\n * toSqlAlias('foo bar'); //=> 'fb'\n * toSqlAlias('book'); //=> 'b'\n * toSqlAlias('article-category'); //=> 'ac'\n**/\nexport const toSqlAlias = (input: string): string => {\n  return snakeCase(input)\n    .split('_')\n    .reduce((acc, word) => acc.concat(word[0]), '');\n};\n\nexport interface ToAbbreviationOptions {\n  maxLength?: number;\n  minLength?: number;\n  lang?: 'uk' | 'ru' | 'mn';\n  iteration?: number;\n}\n\n/**\n * Remove vowels from a word.\n * @param word - word to remove vowels from\n * @returns word without vowels\n * @example\n * removeVowels('foo'); //=> 'f'\n */\nexport const removeVowels = (word: string) => {\n  return word.replace(/[aeiou]/gi, '');\n};\n\n/**\n * Convert a string to abbreviation.\n * @example\n * toAbbreviation('Sabbath Schook'); //=> 'SB'\n * toAbbreviation('Рожеві окуляри', {\n *  lang: 'uk',\n * }); //=> 'RO'\n * toAbbreviation('Удивительные факты', {\n *  lang: 'ru',\n * }); //=> 'UF'\n */\nexport const toAbbreviation = (input: string, opts?: ToAbbreviationOptions): string => {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const transliterator = (cyrillicToTranslit as any)(opts?.lang ? {\n    preset: opts.lang,\n  } : undefined);\n\n  const words = transliterator\n    .transform(input)\n    .toUpperCase()\n    .replace(/[^A-Z ]/g, '')\n    .split(' ')\n    .filter((word: string) => word.length > 0);\n\n  // .map((word) =>).toUpperCase());\n\n  let abbreviation = '';\n\n  // Sabbath School => SS\n  if (words.length > 1) {\n    abbreviation = words.reduce((acc: string, word: string) => {\n      if (word.length >= 1) {\n        acc += word[0];\n      }\n\n      return acc;\n    }, '');\n  } else if (words.length === 1) {\n    const word = words[0];\n\n    // Sabbath => SBBTH\n    if (word.length > 1) {\n      abbreviation = word.slice(0, 1) + removeVowels(word.slice(1));\n    } else {\n      abbreviation = word;\n    }\n  }\n\n  // If the maxLength option is set, trim the abbreviation before adding random characters and appending digits\n  if (opts?.maxLength && !opts?.iteration) {\n    abbreviation = abbreviation.slice(0, opts.maxLength);\n  }\n\n  // If the minLength option is set, ensure the abbreviation meets the minimum length by appending random characters before appending digits\n  if (opts?.minLength && abbreviation.length < opts.minLength) {\n    let charsNeeded = opts.minLength - abbreviation.length;\n    if (opts?.iteration && opts?.iteration > 0) {\n      charsNeeded -= 1;\n    }\n\n    if (charsNeeded > 0) {\n      abbreviation += createRandomAbbreviationString(charsNeeded).toUpperCase();\n    }\n  }\n\n  // Append a number based on the iteration option\n  if (opts?.iteration) {\n    if (opts?.maxLength) {\n      // Calculate the maximum length the abbreviation can be, considering the digits and random characters\n      const maxAbbrLength = opts.maxLength - 1;\n      abbreviation = abbreviation.slice(0, maxAbbrLength);\n    }\n\n    abbreviation += opts.iteration;\n  }\n\n  return abbreviation;\n};\n","/**\n * Decline a noun based on a number.\n * @example\n * const words = ['элемент', 'элемента', 'элементов'];\n *\n * decline(0, words, false) // => 'элементов'\n * decline(24, words, false) // => 'элемента'\n * decline(21, words, false) // => 'элемент'\n *\n * decline(0, words) // => '0 элементов'\n * decline(24, words) // => '24 элемента'\n * decline(21, words) // => '21 элемент'\n */\nexport const decline = (n: number, words: string[], concat = true) => {\n  const word =\n    words[\n      n % 100 > 4 && n % 100 < 20\n        ? 2\n        : [2, 0, 1, 1, 1, 2][n % 10 < 5 ? n % 10 : 5]\n    ];\n\n  return concat ? `${n} ${word}` : word;\n};\n","import * as pluralize from 'pluralize';\n\n/**\n * Change the plural form of a word to its singular form.\n * @example\n * pluralToSingular('books'); //=> 'book'\n */\nexport const singularToPlural = (input: string): string => {\n  return pluralize.plural(input);\n};\n\n/**\n * Change the singular form of a word to its plural form.\n * @example\n * singularToPlural('book'); //=> 'books'\n */\nexport const pluralToSingular = (input: string): string => {\n  return pluralize.singular(input);\n};\n\n/**\n * Checks if a given word is in its plural form.\n *\n * @param word - The word to check for plural form\n * @returns `true` if the word is plural, `false` if it's singular\n *\n * @example\n * ```typescript\n * isPlural(\"cats\"); // true\n * isPlural(\"cat\");  // false\n * ```\n */\nexport const isPlural = (word: string): boolean =>\n  singularToPlural(word) === word;\n\n"],"mappings":"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"}

package/eslint.config.cjs

@@ -0,0 +1,14 @@
+//
+// @pkg 📦 DeepVision ESLint Config [NestJS]
+// @version 📍 1.0.0
+// @author 🐳 DeepVision Team <code@deepvision.team>
+//
+// Documentation reference: https://eslint.org/docs/user-guide/configuring/
+// ESLint versions: https://eslint.org/blog/
+//
+// eslint-disable-next-line @typescript-eslint/no-require-imports, node/no-unpublished-require
+const deep = require('@deepvision/eslint-plugin');
+
+module.exports = [
+  ...deep.default.configs.node,
+];

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@pcg/text-kit",
+  "version": "1.0.0-alpha.0",
+  "description": "Helps you transform text and words programmatically",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "change-case": "^5.4.4",
+    "cyrillic-to-translit-js": "^3.2.1",
+    "nanoid": "^5.1.6",
+    "pluralize": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/pluralize": "^0.0.33",
+    "@vitest/ui": "^3.2.4",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint \"src/**/*.ts\""
+  }
+}