@etsoo/shared 1.0.57 → 1.0.61

package/README.md

@@ -124,8 +124,8 @@ String and other related utilities
 
 |Name|Description|
 |---:|---|
-|formatLowerLetter|Format word's first letter to lower case|
-|formatUpperLetter|Format word's first letter to upper case|
+|formatInitial|Format inital character to lower case or upper case|
+|formatString|Format string with parameters|
 |getDataChanges|Get data changed fields with input data updated|
 |getTimeZone|Get time zone|
 |joinItems|Join items as a string|

package/__tests__/DomUtils.ts

@@ -133,17 +133,27 @@ test('Tests for dataAs', () => {
     formData.append('price', '34.25');
     formData.append('options', '1,2,3,4');
     formData.append('memo', 'Memo');
+    formData.append('email', 'a@b');
+    formData.append('email', 'c@d');
+    formData.append('code', '123');
+    formData.append('code', '456');
 
     const data = DomUtils.dataAs(formData, {
         id: 'number',
         name: 'string',
         price: 'number',
-        options: 'number[]'
+        options: 'number[]',
+        email: 'string[]',
+        code: 'number[]'
     });
 
     expect(data.id).toStrictEqual(1234);
     expect(data.options?.length).toStrictEqual(4);
     expect(data.options![0]).toStrictEqual(1);
+
+    expect(data.email).toEqual(['a@b', 'c@d']);
+    expect(data.code?.length).toStrictEqual(2);
+    expect(data.code).toEqual([123, 456]);
     expect(data).not.toHaveProperty('memo', 'Memo');
 
     const keepSourceData = DomUtils.dataAs(

package/__tests__/Utils.ts

@@ -23,12 +23,17 @@ test('Tests for getDataChanges', () => {
     expect(input.amount).toBeUndefined();
 });
 
-test('Tests for formatLowerLetter', () => {
-    expect(Utils.formatLowerLetter('HelloWorld')).toBe('helloWorld');
+test('Tests for formatInitial', () => {
+    expect(Utils.formatInitial('HelloWorld')).toBe('helloWorld');
+    expect('HelloWorld'.formatInitial(false)).toBe('helloWorld');
+    expect('hello'.formatInitial(true)).toBe('Hello');
 });
 
-test('Tests for formatUpperLetter', () => {
-    expect(Utils.formatUpperLetter('hello')).toBe('Hello');
+test('Tests for formatString', () => {
+    const template = '{0} is first item, {1} is second item, {0} repeat';
+    const result = 'aa is first item, bb is second item, aa repeat';
+    expect(Utils.formatString(template, 'aa', 'bb')).toBe(result);
+    expect(template.format('aa', 'bb')).toBe(result);
 });
 
 test('Tests for joinItems', () => {
@@ -48,7 +53,10 @@ test('Tests for newGUID', () => {
 });
 
 test('Tests for removeNonLetters', () => {
-    expect(Utils.removeNonLetters('1234-5678@abc.')).toBe('12345678abc');
+    const input = '1234-5678@abc.';
+    const result = '12345678abc';
+    expect(Utils.removeNonLetters(input)).toBe(result);
+    expect(input.removeNonLetters()).toBe(result);
 });
 
 test('Tests for objectEqual', () => {

package/lib/cjs/DomUtils.js

@@ -94,9 +94,7 @@ var DomUtils;
         // Properties
         const properties = Object.keys(template);
         // Entries
-        const entries = isFormData(source)
-            ? source.entries()
-            : Object.entries(source);
+        const entries = Object.entries(isFormData(source) ? formDataToObject(source) : source);
         for (const [key, value] of entries) {
             // Is included or keepSource
             const property = (_a = properties.find((p) => p.localeCompare(key, 'en', { sensitivity: 'base' }) ===

package/lib/cjs/Utils.d.ts

@@ -1,18 +1,42 @@
 import { DataTypes } from './DataTypes';
+declare global {
+    interface String {
+        /**
+         * Format string
+         * @param this Template
+         * @param parameters Parameters to fill the template
+         */
+        format(this: string, ...parameters: string[]): string;
+        /**
+         * Forat inital character
+         * @param this Input string
+         * @param upperCase To upper case or lower case
+         */
+        formatInitial(this: string, upperCase: boolean): string;
+        /**
+         * Remove non letters (0-9, a-z, A-Z)
+         * @param this Input string
+         */
+        removeNonLetters(this: string): string;
+    }
+}
 /**
  * Utilities
  */
 export declare namespace Utils {
     /**
-     * Format word's first letter to lower case
-     * @param word Word
+     * Format inital character to lower case or upper case
+     * @param input Input string
+     * @param upperCase To upper case or lower case
      */
-    function formatLowerLetter(word: string): string;
+    function formatInitial(input: string, upperCase?: boolean): string;
     /**
-     * Format word's first letter to upper case
-     * @param word Word
+     * Format string with parameters
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
      */
-    function formatUpperLetter(word: string): string;
+    function formatString(template: string, ...parameters: string[]): string;
     /**
      * Get data changed fields with input data updated
      * @param input Input data

package/lib/cjs/Utils.js

@@ -2,27 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
 const DataTypes_1 = require("./DataTypes");
+String.prototype.format = function (...parameters) {
+    let template = this;
+    parameters.forEach((value, index) => {
+        template = template.replace(new RegExp(`\\{${index}\\}`, 'g'), value);
+    });
+    return template;
+};
+String.prototype.formatInitial = function (upperCase = false) {
+    const initial = this.charAt(0);
+    return ((upperCase ? initial.toUpperCase() : initial.toLowerCase()) +
+        this.slice(1));
+};
+String.prototype.removeNonLetters = function () {
+    return this.replace(/[^a-zA-Z0-9]/g, '');
+};
 /**
  * Utilities
  */
 var Utils;
 (function (Utils) {
     /**
-     * Format word's first letter to lower case
-     * @param word Word
+     * Format inital character to lower case or upper case
+     * @param input Input string
+     * @param upperCase To upper case or lower case
      */
-    function formatLowerLetter(word) {
-        return word.charAt(0).toLowerCase() + word.slice(1);
+    function formatInitial(input, upperCase = false) {
+        return input.formatInitial(upperCase);
     }
-    Utils.formatLowerLetter = formatLowerLetter;
+    Utils.formatInitial = formatInitial;
     /**
-     * Format word's first letter to upper case
-     * @param word Word
+     * Format string with parameters
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
      */
-    function formatUpperLetter(word) {
-        return word.charAt(0).toUpperCase() + word.slice(1);
+    function formatString(template, ...parameters) {
+        return template.format(...parameters);
     }
-    Utils.formatUpperLetter = formatUpperLetter;
+    Utils.formatString = formatString;
     /**
      * Get data changed fields with input data updated
      * @param input Input data
@@ -173,9 +191,7 @@ var Utils;
      * @returns Result
      */
     Utils.removeNonLetters = (input) => {
-        if (input == null || input === '')
-            return input;
-        return input.replace(/[^a-zA-Z0-9]/g, '');
+        return input === null || input === void 0 ? void 0 : input.removeNonLetters();
     };
     /**
      * Set source with new labels
@@ -206,9 +222,9 @@ var Utils;
     Utils.snakeNameToWord = (name, firstOnly = false) => {
         const items = name.split('_');
         if (firstOnly) {
-            items[0] = formatUpperLetter(items[0]);
+            items[0] = items[0].formatInitial(true);
             return items.join(' ');
         }
-        return items.map((part) => formatUpperLetter(part)).join(' ');
+        return items.map((part) => part.formatInitial(true)).join(' ');
     };
 })(Utils = exports.Utils || (exports.Utils = {}));

package/lib/mjs/DomUtils.js

@@ -91,9 +91,7 @@ export var DomUtils;
         // Properties
         const properties = Object.keys(template);
         // Entries
-        const entries = isFormData(source)
-            ? source.entries()
-            : Object.entries(source);
+        const entries = Object.entries(isFormData(source) ? formDataToObject(source) : source);
         for (const [key, value] of entries) {
             // Is included or keepSource
             const property = (_a = properties.find((p) => p.localeCompare(key, 'en', { sensitivity: 'base' }) ===

package/lib/mjs/Utils.d.ts

@@ -1,18 +1,42 @@
 import { DataTypes } from './DataTypes';
+declare global {
+    interface String {
+        /**
+         * Format string
+         * @param this Template
+         * @param parameters Parameters to fill the template
+         */
+        format(this: string, ...parameters: string[]): string;
+        /**
+         * Forat inital character
+         * @param this Input string
+         * @param upperCase To upper case or lower case
+         */
+        formatInitial(this: string, upperCase: boolean): string;
+        /**
+         * Remove non letters (0-9, a-z, A-Z)
+         * @param this Input string
+         */
+        removeNonLetters(this: string): string;
+    }
+}
 /**
  * Utilities
  */
 export declare namespace Utils {
     /**
-     * Format word's first letter to lower case
-     * @param word Word
+     * Format inital character to lower case or upper case
+     * @param input Input string
+     * @param upperCase To upper case or lower case
      */
-    function formatLowerLetter(word: string): string;
+    function formatInitial(input: string, upperCase?: boolean): string;
     /**
-     * Format word's first letter to upper case
-     * @param word Word
+     * Format string with parameters
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
      */
-    function formatUpperLetter(word: string): string;
+    function formatString(template: string, ...parameters: string[]): string;
     /**
      * Get data changed fields with input data updated
      * @param input Input data

package/lib/mjs/Utils.js

@@ -1,25 +1,43 @@
 import { DataTypes } from './DataTypes';
+String.prototype.format = function (...parameters) {
+    let template = this;
+    parameters.forEach((value, index) => {
+        template = template.replace(new RegExp(`\\{${index}\\}`, 'g'), value);
+    });
+    return template;
+};
+String.prototype.formatInitial = function (upperCase = false) {
+    const initial = this.charAt(0);
+    return ((upperCase ? initial.toUpperCase() : initial.toLowerCase()) +
+        this.slice(1));
+};
+String.prototype.removeNonLetters = function () {
+    return this.replace(/[^a-zA-Z0-9]/g, '');
+};
 /**
  * Utilities
  */
 export var Utils;
 (function (Utils) {
     /**
-     * Format word's first letter to lower case
-     * @param word Word
+     * Format inital character to lower case or upper case
+     * @param input Input string
+     * @param upperCase To upper case or lower case
      */
-    function formatLowerLetter(word) {
-        return word.charAt(0).toLowerCase() + word.slice(1);
+    function formatInitial(input, upperCase = false) {
+        return input.formatInitial(upperCase);
     }
-    Utils.formatLowerLetter = formatLowerLetter;
+    Utils.formatInitial = formatInitial;
     /**
-     * Format word's first letter to upper case
-     * @param word Word
+     * Format string with parameters
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
      */
-    function formatUpperLetter(word) {
-        return word.charAt(0).toUpperCase() + word.slice(1);
+    function formatString(template, ...parameters) {
+        return template.format(...parameters);
     }
-    Utils.formatUpperLetter = formatUpperLetter;
+    Utils.formatString = formatString;
     /**
      * Get data changed fields with input data updated
      * @param input Input data
@@ -170,9 +188,7 @@ export var Utils;
      * @returns Result
      */
     Utils.removeNonLetters = (input) => {
-        if (input == null || input === '')
-            return input;
-        return input.replace(/[^a-zA-Z0-9]/g, '');
+        return input === null || input === void 0 ? void 0 : input.removeNonLetters();
     };
     /**
      * Set source with new labels
@@ -203,9 +219,9 @@ export var Utils;
     Utils.snakeNameToWord = (name, firstOnly = false) => {
         const items = name.split('_');
         if (firstOnly) {
-            items[0] = formatUpperLetter(items[0]);
+            items[0] = items[0].formatInitial(true);
             return items.join(' ');
         }
-        return items.map((part) => formatUpperLetter(part)).join(' ');
+        return items.map((part) => part.formatInitial(true)).join(' ');
     };
 })(Utils || (Utils = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.0.57",
+    "version": "1.0.61",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -24,6 +24,11 @@
             "<rootDir>/__tests__/**/*.ts"
         ],
         "testEnvironment": "jsdom",
+        "moduleFileExtensions": [
+            "js",
+            "ts",
+            "d.ts"
+        ],
         "transform": {
             ".+\\.ts$": "ts-jest"
         }

package/src/DomUtils.ts

@@ -108,9 +108,9 @@ export namespace DomUtils {
         const properties = Object.keys(template);
 
         // Entries
-        const entries = isFormData(source)
-            ? source.entries()
-            : Object.entries(source);
+        const entries = Object.entries(
+            isFormData(source) ? formDataToObject(source) : source
+        );
 
         for (const [key, value] of entries) {
             // Is included or keepSource

package/src/Utils.ts

@@ -1,23 +1,76 @@
 import { DataTypes } from './DataTypes';
 
+declare global {
+    interface String {
+        /**
+         * Format string
+         * @param this Template
+         * @param parameters Parameters to fill the template
+         */
+        format(this: string, ...parameters: string[]): string;
+
+        /**
+         * Forat inital character
+         * @param this Input string
+         * @param upperCase To upper case or lower case
+         */
+        formatInitial(this: string, upperCase: boolean): string;
+
+        /**
+         * Remove non letters (0-9, a-z, A-Z)
+         * @param this Input string
+         */
+        removeNonLetters(this: string): string;
+    }
+}
+
+String.prototype.format = function (
+    this: string,
+    ...parameters: string[]
+): string {
+    let template = this;
+    parameters.forEach((value, index) => {
+        template = template.replace(new RegExp(`\\{${index}\\}`, 'g'), value);
+    });
+    return template;
+};
+
+String.prototype.formatInitial = function (
+    this: string,
+    upperCase: boolean = false
+) {
+    const initial = this.charAt(0);
+    return (
+        (upperCase ? initial.toUpperCase() : initial.toLowerCase()) +
+        this.slice(1)
+    );
+};
+
+String.prototype.removeNonLetters = function (this: string) {
+    return this.replace(/[^a-zA-Z0-9]/g, '');
+};
+
 /**
  * Utilities
  */
 export namespace Utils {
     /**
-     * Format word's first letter to lower case
-     * @param word Word
+     * Format inital character to lower case or upper case
+     * @param input Input string
+     * @param upperCase To upper case or lower case
      */
-    export function formatLowerLetter(word: string) {
-        return word.charAt(0).toLowerCase() + word.slice(1);
+    export function formatInitial(input: string, upperCase: boolean = false) {
+        return input.formatInitial(upperCase);
     }
 
     /**
-     * Format word's first letter to upper case
-     * @param word Word
+     * Format string with parameters
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
      */
-    export function formatUpperLetter(word: string) {
-        return word.charAt(0).toUpperCase() + word.slice(1);
+    export function formatString(template: string, ...parameters: string[]) {
+        return template.format(...parameters);
     }
 
     /**
@@ -200,8 +253,7 @@ export namespace Utils {
      * @returns Result
      */
     export const removeNonLetters = (input?: string) => {
-        if (input == null || input === '') return input;
-        return input.replace(/[^a-zA-Z0-9]/g, '');
+        return input?.removeNonLetters();
     };
 
     /**
@@ -246,10 +298,10 @@ export namespace Utils {
     ) => {
         const items = name.split('_');
         if (firstOnly) {
-            items[0] = formatUpperLetter(items[0]);
+            items[0] = items[0].formatInitial(true);
             return items.join(' ');
         }
 
-        return items.map((part) => formatUpperLetter(part)).join(' ');
+        return items.map((part) => part.formatInitial(true)).join(' ');
     };
 }