@pcg/text-kit 1.0.0-alpha.0 → 1.0.0-alpha.1

package/dist/index.d.ts

@@ -167,7 +167,6 @@ declare const toSqlAlias: (input: string) => string;
 interface ToAbbreviationOptions {
   maxLength?: number;
   minLength?: number;
-  lang?: 'uk' | 'ru' | 'mn';
   iteration?: number;
 }
 /**
@@ -179,15 +178,10 @@ interface ToAbbreviationOptions {
  */
 declare const removeVowels: (word: string) => string;
 /**
- * Convert a string to abbreviation.
+ * Convert a string to abbreviation (Latin characters only).
  * @example
- * toAbbreviation('Sabbath Schook'); //=> 'SB'
- * toAbbreviation('Рожеві окуляри', {
- *  lang: 'uk',
- * }); //=> 'RO'
- * toAbbreviation('Удивительные факты', {
- *  lang: 'ru',
- * }); //=> 'UF'
+ * toAbbreviation('Sabbath School'); //=> 'SS'
+ * toAbbreviation('Hello World'); //=> 'HW'
  */
 declare const toAbbreviation: (input: string, opts?: ToAbbreviationOptions) => string;
 //#endregion

package/dist/index.js

@@ -1,5 +1,4 @@
 import * as cc from "change-case";
-import cyrillicToTranslit from "cyrillic-to-translit-js";
 import { customAlphabet } from "nanoid/non-secure";
 import * as pluralize from "pluralize";
 
@@ -171,7 +170,7 @@ const capitalCase = (input) => {
 * Alias to "toUcSentence"
 * @deprecated use capitalCase instead
 **/
-const capitalize = (input) => toUcSentence(input);
+const capitalize = (input) => capitalCase(input);
 /**
 * Convert a string to lower cased sentence.
 * @deprecated use lowerSentenceCase instead
@@ -222,18 +221,13 @@ const removeVowels = (word) => {
 	return word.replace(/[aeiou]/gi, "");
 };
 /**
-* Convert a string to abbreviation.
+* Convert a string to abbreviation (Latin characters only).
 * @example
-* toAbbreviation('Sabbath Schook'); //=> 'SB'
-* toAbbreviation('Рожеві окуляри', {
-*  lang: 'uk',
-* }); //=> 'RO'
-* toAbbreviation('Удивительные факты', {
-*  lang: 'ru',
-* }); //=> 'UF'
+* toAbbreviation('Sabbath School'); //=> 'SS'
+* toAbbreviation('Hello World'); //=> 'HW'
 */
 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);
+	const words = 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];
@@ -244,18 +238,18 @@ const toAbbreviation = (input, opts) => {
 		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?.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 (opts.iteration && opts.iteration > 0) charsNeeded -= 1;
 		if (charsNeeded > 0) abbreviation += createRandomAbbreviationString(charsNeeded).toUpperCase();
 	}
 	if (opts?.iteration) {
-		if (opts?.maxLength) {
+		if (opts.maxLength) {
 			const maxAbbrLength = opts.maxLength - 1;
 			abbreviation = abbreviation.slice(0, maxAbbrLength);
 		}
-		abbreviation += opts.iteration;
+		abbreviation += String(opts.iteration);
 	}
 	return abbreviation;
 };
@@ -284,7 +278,7 @@ const decline = (n, words, concat = true) => {
 		1,
 		2
 	][n % 10 < 5 ? n % 10 : 5]];
-	return concat ? `${n} ${word}` : word;
+	return concat ? `${String(n)} ${word}` : word;
 };
 
 //#endregion

package/dist/index.js.map

@@ -1 +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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"}
+{"version":3,"file":"index.js","names":["words: string[]"],"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 { 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) => capitalCase(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  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 (Latin characters only).\n * @example\n * toAbbreviation('Sabbath School'); //=> 'SS'\n * toAbbreviation('Hello World'); //=> 'HW'\n */\nexport const toAbbreviation = (input: string, opts?: ToAbbreviationOptions): string => {\n  const words: string[] = input\n    .toUpperCase()\n    .replace(/[^A-Z ]/g, '')\n    .split(' ')\n    .filter((word: string) => word.length > 0);\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 += String(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 ? `${String(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"],"mappings":"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"}

package/package.json

@@ -1,13 +1,24 @@
 {
   "name": "@pcg/text-kit",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.1",
   "description": "Helps you transform text and words programmatically",
+  "license": "MIT",
+  "author": {
+    "email": "code@deepvision.team",
+    "name": "DeepVision Code"
+  },
+  "contributors": [
+    "Vitaliy Angolenko <v.angolenko@deepvision.software>",
+    "Sergii Sadovyi <s.sadovyi@deepvision.software>"
+  ],
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "change-case": "^5.4.4",
-    "cyrillic-to-translit-js": "^3.2.1",
     "nanoid": "^5.1.6",
     "pluralize": "^8.0.0"
   },
@@ -21,6 +32,6 @@
     "build": "tsdown",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint \"src/**/*.ts\""
+    "lint": "eslint \"src/**/*.ts\" --fix"
   }
 }

package/.turbo/turbo-build.log

@@ -1,15 +0,0 @@
-
-
-> @pcg/text-kit@1.0.0-alpha.0 build /Users/serg_sadovyi/prj/deepvisionsoftware.github/pcg/packages/text-kit
-> tsdown
-
-ℹ tsdown v0.15.12 powered by rolldown v1.0.0-beta.45
-ℹ Using tsdown config: /Users/serg_sadovyi/prj/deepvisionsoftware.github/pcg/packages/text-kit/tsdown.config.ts
-ℹ entry: src/index.ts
-ℹ tsconfig: ../../tsconfig.build.json
-ℹ Build start
-ℹ dist/index.js       9.79 kB │ gzip: 2.42 kB
-ℹ dist/index.js.map  14.23 kB │ gzip: 3.60 kB
-ℹ dist/index.d.ts     8.15 kB │ gzip: 1.67 kB
-ℹ 3 files, total: 32.17 kB
-✔ Build complete in 580ms

package/eslint.config.cjs

@@ -1,14 +0,0 @@
-//
-// @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/src/cases.ts

@@ -1,317 +0,0 @@
-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

@@ -1,23 +0,0 @@
-/**
- * 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

@@ -1,41 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

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

package/src/pluralize.ts

@@ -1,35 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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 элемент');
-});

package/tests/entities.test.ts

@@ -1,47 +0,0 @@
-import {
-  describe, expect,
-  test,
-} from 'vitest';
-
-import { createEntityTypeNames } from '../src/entities.js';
-
-describe('createEntityTypeNames', () => {
-  test('should return correct entity type variations for PascalCase input', () => {
-    const result = createEntityTypeNames('CodePuzzle');
-
-    expect(result.pluralEntityType).toBe('CodePuzzles');
-    expect(result.camelCaseEntityType).toBe('codePuzzle');
-    expect(result.pascalCaseEntityType).toBe('CodePuzzle');
-    expect(result.pluralCamelCaseEntityType).toBe('codePuzzles');
-    expect(result.pluralPascalCaseEntityType).toBe('CodePuzzles');
-    expect(result.createMutationName).toBe('createCodePuzzle');
-    expect(result.updateMutationName).toBe('updateCodePuzzle');
-    expect(result.deleteMutationName).toBe('deleteCodePuzzle');
-    expect(result.publishMutationName).toBe('publishCodePuzzle');
-    expect(result.unpublishMutationName).toBe('unpublishCodePuzzle');
-  });
-
-  test('should return correct entity type variations for camelCase input', () => {
-    const result = createEntityTypeNames('userProfile');
-
-    expect(result.pluralEntityType).toBe('userProfiles');
-    expect(result.camelCaseEntityType).toBe('userProfile');
-    expect(result.pascalCaseEntityType).toBe('UserProfile');
-    expect(result.pluralCamelCaseEntityType).toBe('userProfiles');
-    expect(result.pluralPascalCaseEntityType).toBe('UserProfiles');
-    expect(result.createMutationName).toBe('createUserProfile');
-    expect(result.updateMutationName).toBe('updateUserProfile');
-    expect(result.deleteMutationName).toBe('deleteUserProfile');
-    expect(result.dublicateMutationName).toBe('dublicateUserProfile');
-    expect(result.publishMutationName).toBe('publishUserProfile');
-    expect(result.unpublishMutationName).toBe('unpublishUserProfile');
-  });
-
-  test('should handle irregular plural forms correctly', () => {
-    const result = createEntityTypeNames('Person');
-
-    expect(result.pluralEntityType).toBe('People');
-    expect(result.pluralCamelCaseEntityType).toBe('people');
-    expect(result.pluralPascalCaseEntityType).toBe('People');
-  });
-});

package/tests/generators.test.ts

@@ -1,11 +0,0 @@
-import { createNumericCode } from '../src/generators';
-
-describe('Generators', () => {
-  test.each<[number, number, string]>([
-    [1, 3, '001'],
-    [3, 1, '3'],
-    [3, 2, '03'],
-  ])('createNumericCode(%d, %d) = %s', (num, length, expected) => {
-    expect(createNumericCode(num, length)).toBe(expected);
-  });
-});

package/tests/pluralize.test.ts

@@ -1,28 +0,0 @@
-import {
-  isPlural,
-  pluralToSingular, singularToPlural,
-} from '../src/pluralize.js';
-
-import {
-  describe, expect, test,
-} from 'vitest';
-
-describe('Is Plural', () => {
-  test('must return true for plural words', () => {
-    expect(isPlural('microcourses')).toBe(true);
-  });
-
-  test('must return false for singular words', () => {
-    expect(isPlural('microcourse')).toBe(false);
-  });
-});
-
-describe('Pluralize', () => {
-  test('must convert singular to plural', () => {
-    expect(singularToPlural('microcourse')).toEqual('microcourses');
-  });
-
-  test('must convert plural to singular', () => {
-    expect(pluralToSingular('microcourses')).toEqual('microcourse');
-  });
-});

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "moduleResolution": "bundler",
-  },
-  "include": ["src/**/*.ts", "tests/**/*.ts"],
-  "exclude": ["node_modules", "dist"],
-}

package/tsconfig.lib.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "moduleResolution": "bundler",
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"],
-}

package/tsdown.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'tsdown';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  tsconfig: '../../tsconfig.build.json',
-  outDir: 'dist',
-  dts: true,
-  clean: true,
-  sourcemap: true,
-  format: 'esm',
-});

package/vitest.config.ts

@@ -1,19 +0,0 @@
-// / <reference types="vitest" />
-// eslint-disable-next-line node/no-unpublished-import
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['tests/**/*.test.ts'],
-    globals: true,
-    typecheck: {
-      tsconfig: './tsconfig.json',
-    },
-  },
-  resolve: {
-    alias: {
-      '@': new URL('./src', import.meta.url).pathname,
-    },
-  },
-});