@guanghechen/string 1.0.1

package/README.md

@@ -0,0 +1,100 @@
+<header>
+  <h1 align="center">
+    <a href="https://github.com/guanghechen/sora/tree/@guanghechen/string@1.0.1/packages/string#readme">@guanghechen/string</a>
+  </h1>
+  <div align="center">
+    <a href="https://www.npmjs.com/package/@guanghechen/string">
+      <img
+        alt="Npm Version"
+        src="https://img.shields.io/npm/v/@guanghechen/string.svg"
+      />
+    </a>
+    <a href="https://www.npmjs.com/package/@guanghechen/string">
+      <img
+        alt="Npm Download"
+        src="https://img.shields.io/npm/dm/@guanghechen/string.svg"
+      />
+    </a>
+    <a href="https://www.npmjs.com/package/@guanghechen/string">
+      <img
+        alt="Npm License"
+        src="https://img.shields.io/npm/l/@guanghechen/string.svg"
+      />
+    </a>
+    <a href="https://github.com/nodejs/node">
+      <img
+        alt="Node.js Version"
+        src="https://img.shields.io/node/v/@guanghechen/string"
+      />
+    </a>
+    <a href="https://github.com/facebook/jest">
+      <img
+        alt="Tested with Jest"
+        src="https://img.shields.io/badge/tested_with-jest-9c465e.svg"
+      />
+    </a>
+    <a href="https://github.com/prettier/prettier">
+      <img
+        alt="Code Style: prettier"
+        src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square"
+      />
+    </a>
+  </div>
+</header>
+<br/>
+
+Utilities for processing strings or stringify other type data.
+
+## Install
+
+* npm
+
+  ```bash
+  npm install --save-dev @guanghechen/string
+  ```
+
+* yarn
+
+  ```bash
+  yarn add --dev @guanghechen/string
+  ```
+
+## Usage
+
+* `transformer` utilities
+
+  Name                  | Description
+  :--------------------:|:---------------------------------------
+  `toCamelCase`         | `'test string' => 'testString'`
+  `toCapitalCase`       | `'test string' => 'Test String'`
+  `toConstantCase`      | `'test string' => 'TEST_STRING'`
+  `toDotCase`           | `'test string' => 'test.string'`
+  `toKebabCase`         | `'test string' => 'test-string'`
+  `toLowerCase`         | `'TEST STRING' => 'test string'`
+  `toPascalCase`        | `'test string' => 'TestString'`
+  `toPathCase`          | `'test string' => 'test/string'`
+  `toSentenceCase`      | `'testString' => 'Test string'`
+  `toSnakeCase`         | `'test string' => 'test_string'`
+  `toTitleCase`         | `'a simple test' => 'A Simple Test'`
+  `toUpperCase`         | `'test string' => 'TEST STRING'`
+
+  - `composeTextTransformers`: Compose multiple ITextTransformer into one.
+
+    ```typescript
+    import {
+      composeTextTransformers,
+      toKebabCase,
+      toTrim,
+    } from '@guanghechen/string'
+
+    // function composeTextTransformers (
+    //   ...transformers: ReadonlyArray<ITextTransformer>
+    // ): ITextTransformer
+
+    const transform = composeTextTransformers(toTrim, toKebabCase)
+    const text: string = transform(' TeSt_StrinG ')
+    // => 'test-string'
+    ```
+
+
+[homepage]: https://github.com/guanghechen/sora/tree/@guanghechen/string@1.0.1/packages/string#readme

package/lib/cjs/index.cjs

@@ -0,0 +1,202 @@
+'use strict';
+
+const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+const SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+const SPLIT_NUMBER_LOWER_RE = /(\d)(\p{Ll})/gu;
+const SPLIT_LETTER_NUMBER_RE = /(\p{L})(\d)/gu;
+const DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+const SPLIT_REPLACE_VALUE = '$1\0$2';
+function split(input, options = {}) {
+    let result = input
+        .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)
+        .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    if (options.separateNumbers) {
+        result = result
+            .replace(SPLIT_NUMBER_LOWER_RE, SPLIT_REPLACE_VALUE)
+            .replace(SPLIT_LETTER_NUMBER_RE, SPLIT_REPLACE_VALUE);
+    }
+    result = result.replace(DEFAULT_STRIP_REGEXP, '\0');
+    let start = 0;
+    let end = result.length;
+    while (result.charAt(start) === '\0')
+        start += 1;
+    if (start === end)
+        return [];
+    while (result.charAt(end - 1) === '\0')
+        end -= 1;
+    return result.slice(start, end).split(/\0/g);
+}
+function camelCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = pascalCaseTransformFactory(lower, upper);
+    return split(input, options)
+        .map((word, index) => {
+        if (index === 0)
+            return lower(word);
+        return transform(word, index);
+    })
+        .join('');
+}
+function pascalCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return split(input, options).map(pascalCaseTransformFactory(lower, upper)).join('');
+}
+function capitalCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return split(input, options).map(capitalCaseTransformFactory(lower, upper)).join(' ');
+}
+function constantCase(input, options) {
+    const upper = upperFactory(options?.locale);
+    return split(input, options).map(upper).join('_');
+}
+function dotCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('.');
+}
+function kebabCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('-');
+}
+function pathCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('/');
+}
+function sentenceCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = capitalCaseTransformFactory(lower, upper);
+    return split(input, options)
+        .map((word, index) => {
+        if (index === 0)
+            return transform(word, index);
+        return lower(word);
+    })
+        .join(' ');
+}
+function snakeCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('_');
+}
+function lowerFactory(locale) {
+    return (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+    return (input) => input.toLocaleUpperCase(locale);
+}
+const capitalCaseTransformFactory = (lower, upper) => {
+    return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+};
+const pascalCaseTransformFactory = (lower, upper) => {
+    return (word, index) => {
+        const char0 = word[0];
+        const initial = index > 0 && char0 >= '0' && char0 <= '9' ? '_' + char0 : upper(char0);
+        return initial + lower(word.slice(1));
+    };
+};
+
+const TOKENS = /\S+|./g;
+const IS_MANUAL_CASE = /\p{Ll}(?=[\p{Lu}])|\.\p{L}/u;
+const ALPHANUMERIC_PATTERN = /[\p{L}\d]+/gu;
+const WORD_SEPARATORS = new Set(['—', '–', '-', '―', '/']);
+const SMALL_WORDS = new Set([
+    'an',
+    'and',
+    'as',
+    'at',
+    'because',
+    'but',
+    'by',
+    'en',
+    'for',
+    'if',
+    'in',
+    'neither',
+    'nor',
+    'of',
+    'on',
+    'or',
+    'only',
+    'over',
+    'per',
+    'so',
+    'some',
+    'that',
+    'than',
+    'the',
+    'to',
+    'up',
+    'upon',
+    'v',
+    'vs',
+    'versus',
+    'via',
+    'when',
+    'with',
+    'without',
+    'yet',
+]);
+function titleCase(input, options = {}) {
+    let result = '';
+    let m;
+    const { smallWords = SMALL_WORDS, locale } = typeof options === 'string' || Array.isArray(options) ? { locale: options } : options;
+    while ((m = TOKENS.exec(input)) !== null) {
+        const { 0: token, index } = m;
+        if (IS_MANUAL_CASE.test(token)) {
+            result += token;
+        }
+        else {
+            result += token.replace(ALPHANUMERIC_PATTERN, (m, i) => {
+                if (index > 0 && index + token.length < input.length && smallWords.has(m)) {
+                    return m;
+                }
+                if (i > 1 && !WORD_SEPARATORS.has(input.charAt(index + i - 1))) {
+                    return m;
+                }
+                return m.charAt(0).toLocaleUpperCase(locale) + m.slice(1);
+            });
+        }
+    }
+    return result;
+}
+
+function composeTextTransformers(...transformers) {
+    return text => {
+        let result = text;
+        for (const transformer of transformers) {
+            result = transformer(result);
+        }
+        return result;
+    };
+}
+const toCamelCase = text => camelCase(text);
+const toCapitalCase = text => capitalCase(text);
+const toConstantCase = text => constantCase(text);
+const toDotCase = text => dotCase(text);
+const toKebabCase = text => kebabCase(text);
+const toLowerCase = text => text.toLocaleLowerCase();
+const toPascalCase = text => pascalCase(text);
+const toPathCase = text => pathCase(text);
+const toSentenceCase = text => sentenceCase(text);
+const toSnakeCase = text => snakeCase(text);
+const toTitleCase = text => titleCase(text);
+const toTrim = text => text.trim();
+const toUpperCase = text => text.toLocaleUpperCase();
+
+exports.composeTextTransformers = composeTextTransformers;
+exports.toCamelCase = toCamelCase;
+exports.toCapitalCase = toCapitalCase;
+exports.toConstantCase = toConstantCase;
+exports.toDotCase = toDotCase;
+exports.toKebabCase = toKebabCase;
+exports.toLowerCase = toLowerCase;
+exports.toPascalCase = toPascalCase;
+exports.toPathCase = toPathCase;
+exports.toSentenceCase = toSentenceCase;
+exports.toSnakeCase = toSnakeCase;
+exports.toTitleCase = toTitleCase;
+exports.toTrim = toTrim;
+exports.toUpperCase = toUpperCase;
+//# sourceMappingURL=index.cjs.map

package/lib/esm/index.mjs

@@ -0,0 +1,187 @@
+const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+const SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+const SPLIT_NUMBER_LOWER_RE = /(\d)(\p{Ll})/gu;
+const SPLIT_LETTER_NUMBER_RE = /(\p{L})(\d)/gu;
+const DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+const SPLIT_REPLACE_VALUE = '$1\0$2';
+function split(input, options = {}) {
+    let result = input
+        .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)
+        .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    if (options.separateNumbers) {
+        result = result
+            .replace(SPLIT_NUMBER_LOWER_RE, SPLIT_REPLACE_VALUE)
+            .replace(SPLIT_LETTER_NUMBER_RE, SPLIT_REPLACE_VALUE);
+    }
+    result = result.replace(DEFAULT_STRIP_REGEXP, '\0');
+    let start = 0;
+    let end = result.length;
+    while (result.charAt(start) === '\0')
+        start += 1;
+    if (start === end)
+        return [];
+    while (result.charAt(end - 1) === '\0')
+        end -= 1;
+    return result.slice(start, end).split(/\0/g);
+}
+function camelCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = pascalCaseTransformFactory(lower, upper);
+    return split(input, options)
+        .map((word, index) => {
+        if (index === 0)
+            return lower(word);
+        return transform(word, index);
+    })
+        .join('');
+}
+function pascalCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return split(input, options).map(pascalCaseTransformFactory(lower, upper)).join('');
+}
+function capitalCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return split(input, options).map(capitalCaseTransformFactory(lower, upper)).join(' ');
+}
+function constantCase(input, options) {
+    const upper = upperFactory(options?.locale);
+    return split(input, options).map(upper).join('_');
+}
+function dotCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('.');
+}
+function kebabCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('-');
+}
+function pathCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('/');
+}
+function sentenceCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = capitalCaseTransformFactory(lower, upper);
+    return split(input, options)
+        .map((word, index) => {
+        if (index === 0)
+            return transform(word, index);
+        return lower(word);
+    })
+        .join(' ');
+}
+function snakeCase(input, options) {
+    const lower = lowerFactory(options?.locale);
+    return split(input, options).map(lower).join('_');
+}
+function lowerFactory(locale) {
+    return (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+    return (input) => input.toLocaleUpperCase(locale);
+}
+const capitalCaseTransformFactory = (lower, upper) => {
+    return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+};
+const pascalCaseTransformFactory = (lower, upper) => {
+    return (word, index) => {
+        const char0 = word[0];
+        const initial = index > 0 && char0 >= '0' && char0 <= '9' ? '_' + char0 : upper(char0);
+        return initial + lower(word.slice(1));
+    };
+};
+
+const TOKENS = /\S+|./g;
+const IS_MANUAL_CASE = /\p{Ll}(?=[\p{Lu}])|\.\p{L}/u;
+const ALPHANUMERIC_PATTERN = /[\p{L}\d]+/gu;
+const WORD_SEPARATORS = new Set(['—', '–', '-', '―', '/']);
+const SMALL_WORDS = new Set([
+    'an',
+    'and',
+    'as',
+    'at',
+    'because',
+    'but',
+    'by',
+    'en',
+    'for',
+    'if',
+    'in',
+    'neither',
+    'nor',
+    'of',
+    'on',
+    'or',
+    'only',
+    'over',
+    'per',
+    'so',
+    'some',
+    'that',
+    'than',
+    'the',
+    'to',
+    'up',
+    'upon',
+    'v',
+    'vs',
+    'versus',
+    'via',
+    'when',
+    'with',
+    'without',
+    'yet',
+]);
+function titleCase(input, options = {}) {
+    let result = '';
+    let m;
+    const { smallWords = SMALL_WORDS, locale } = typeof options === 'string' || Array.isArray(options) ? { locale: options } : options;
+    while ((m = TOKENS.exec(input)) !== null) {
+        const { 0: token, index } = m;
+        if (IS_MANUAL_CASE.test(token)) {
+            result += token;
+        }
+        else {
+            result += token.replace(ALPHANUMERIC_PATTERN, (m, i) => {
+                if (index > 0 && index + token.length < input.length && smallWords.has(m)) {
+                    return m;
+                }
+                if (i > 1 && !WORD_SEPARATORS.has(input.charAt(index + i - 1))) {
+                    return m;
+                }
+                return m.charAt(0).toLocaleUpperCase(locale) + m.slice(1);
+            });
+        }
+    }
+    return result;
+}
+
+function composeTextTransformers(...transformers) {
+    return text => {
+        let result = text;
+        for (const transformer of transformers) {
+            result = transformer(result);
+        }
+        return result;
+    };
+}
+const toCamelCase = text => camelCase(text);
+const toCapitalCase = text => capitalCase(text);
+const toConstantCase = text => constantCase(text);
+const toDotCase = text => dotCase(text);
+const toKebabCase = text => kebabCase(text);
+const toLowerCase = text => text.toLocaleLowerCase();
+const toPascalCase = text => pascalCase(text);
+const toPathCase = text => pathCase(text);
+const toSentenceCase = text => sentenceCase(text);
+const toSnakeCase = text => snakeCase(text);
+const toTitleCase = text => titleCase(text);
+const toTrim = text => text.trim();
+const toUpperCase = text => text.toLocaleUpperCase();
+
+export { composeTextTransformers, toCamelCase, toCapitalCase, toConstantCase, toDotCase, toKebabCase, toLowerCase, toPascalCase, toPathCase, toSentenceCase, toSnakeCase, toTitleCase, toTrim, toUpperCase };
+//# sourceMappingURL=index.mjs.map

package/lib/types/index.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Text transformer.
+ */
+type ITextTransformer = (text: string) => string;
+/**
+ * Compose multiple ITextTransformer into one.
+ * @param transformers
+ * @returns
+ */
+declare function composeTextTransformers(...transformers: ReadonlyArray<ITextTransformer>): ITextTransformer;
+/**
+ * Transform into a string with the separator
+ * denoted by the next word capitalized.
+ *
+ *   'test string' => 'testString'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#camelcase
+ */
+declare const toCamelCase: ITextTransformer;
+/**
+ * Transform into a space separated string with each word capitalized.
+ *
+ *    'test string' => 'Test String'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#capitalCase
+ */
+declare const toCapitalCase: ITextTransformer;
+/**
+ * Transform into upper case string with an underscore between words.
+ *
+ *    'test string' => 'TEST_STRING'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#constantCase
+ */
+declare const toConstantCase: ITextTransformer;
+/**
+ * Transform into a lower case string with a period between words.
+ *
+ *    'test string' => 'test.string'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#dotcase
+ */
+declare const toDotCase: ITextTransformer;
+/**
+ * Transform into a lower cased string with dashes between words.
+ *
+ *    'test string' => 'test-string'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#paramcase
+ */
+declare const toKebabCase: ITextTransformer;
+/**
+ * Transforms the string to lower case.
+ *
+ *    'TEST STRING' => 'test string'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#lowerCase
+ */
+declare const toLowerCase: ITextTransformer;
+/**
+ * Transform into a string of capitalized words without separators.
+ *
+ *    'test string' => 'TestString'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#pascalcase
+ */
+declare const toPascalCase: ITextTransformer;
+/**
+ * Transform into a lower case string with slashes between words.
+ *
+ *    'test string' => 'test/string'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#pathcase
+ */
+declare const toPathCase: ITextTransformer;
+/**
+ * Transform into a lower case with spaces between words,
+ * then capitalize the string.
+ *
+ *    'testString' => 'Test string'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#sentencecase
+ */
+declare const toSentenceCase: ITextTransformer;
+/**
+ * Transform into a lower case string with underscores between words.
+ *
+ *    'test string' => 'test_string'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#snakeCase
+ */
+declare const toSnakeCase: ITextTransformer;
+/**
+ * Transform a string into title case following English rules.
+ *
+ *    'a simple test' => 'A Simple Test'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#titlecase
+ */
+declare const toTitleCase: ITextTransformer;
+/**
+ * Perform trim operation
+ *
+ *    ' a simple test  ' => 'a simple test'
+ *
+ * @param text
+ * @returns
+ */
+declare const toTrim: ITextTransformer;
+/**
+ * Transforms the string to upper case.
+ *
+ *    'test string' => 'TEST STRING'
+ *
+ * @param text
+ * @see https://github.com/blakeembrey/change-case#upperCase
+ */
+declare const toUpperCase: ITextTransformer;
+
+export { type ITextTransformer, composeTextTransformers, toCamelCase, toCapitalCase, toConstantCase, toDotCase, toKebabCase, toLowerCase, toPascalCase, toPathCase, toSentenceCase, toSnakeCase, toTitleCase, toTrim, toUpperCase };
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@guanghechen/string",
+  "version": "1.0.1",
+  "description": "Utilities for processing strings or stringify other type data.",
+  "author": {
+    "name": "guanghechen",
+    "url": "https://github.com/guanghechen/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guanghechen/sora/tree/@guanghechen/string@1.0.0",
+    "directory": "packages/string"
+  },
+  "homepage": "https://github.com/guanghechen/sora/tree/@guanghechen/string@1.0.0/packages/string#readme",
+  "keywords": [
+    "string",
+    "string transformer",
+    "string utils"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./lib/esm/index.mjs",
+      "require": "./lib/cjs/index.cjs",
+      "types": "./lib/types/index.d.ts"
+    }
+  },
+  "source": "./src/index.ts",
+  "main": "./lib/cjs/index.cjs",
+  "module": "./lib/esm/index.mjs",
+  "types": "./lib/types/index.d.ts",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 18.0.0"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map",
+    "package.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "gitHead": "2723aaa31e8ac85afed5b25760875db429d88563"
+}