@etsoo/shared 1.1.55 → 1.1.57

package/README.md

@@ -103,6 +103,7 @@ Data type definitions and type safe functions. ListItemType and ListItemType1 ar
 |KeyCollection|Key collection, like { key1: {}, key2: {} }|
 |Keys|Get specific type keys|
 |ObjType|Generic object type|
+|RequireAtLeastOne|Require at least one property of the keys|
 |Simple|Basic or basic array type|
 |SimpleEnum|Simple type enum|
 |SimpleNames|Simple type names|
@@ -232,4 +233,7 @@ String and other related utilities
 |removeNonLetters|Remove non letters (0-9, a-z, A-Z)|
 |replaceNullOrEmpty|Replace null or empty with default value|
 |setLabels|Set source with new labels|
-|snakeNameToWord|Snake name to works, 'snake_name' to 'Snake Name'|
+|snakeNameToWord|Snake name to works, 'snake_name' to 'Snake Name'|
+|trim|Trim chars|
+|trimEnd|Trim end chars|
+|trimStart|Trim start chars|

package/__tests__/Utils.ts

@@ -197,3 +197,21 @@ test('Tests for getResult', () => {
     const valueResult = Utils.getResult(inputNumber);
     expect(valueResult).toBe(5);
 });
+
+test('Tests for trim', () => {
+    expect(Utils.trim('//a/', '/')).toBe('a');
+    expect(Utils.trim('/*/a/', ...['/', '*'])).toBe('a');
+    expect(Utils.trim('abc', ...['/', '*'])).toBe('abc');
+});
+
+test('Tests for trimStart', () => {
+    expect(Utils.trimStart('//a/', '/')).toBe('a/');
+    expect(Utils.trimStart('/*/a/', ...['/', '*'])).toBe('a/');
+    expect(Utils.trimStart('abc', ...['/', '*'])).toBe('abc');
+});
+
+test('Tests for trimEnd', () => {
+    expect(Utils.trimEnd('//a/', '/')).toBe('//a');
+    expect(Utils.trimEnd('/*/a*/', ...['/', '*'])).toBe('/*/a');
+    expect(Utils.trimEnd('abc', ...['/', '*'])).toBe('abc');
+});

package/lib/cjs/DataTypes.d.ts

@@ -183,6 +183,12 @@ export declare namespace DataTypes {
     type Keys<T extends object, R = string | number> = {
         [k in keyof T]: T[k] extends R ? k : never;
     }[keyof T];
+    /**
+     * Require at least one property of the keys
+     */
+    type RequireAtLeastOne<T, Keys extends keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+        [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+    }[Keys];
     /**
      * Culture definiton
      */

package/lib/cjs/Utils.d.ts

@@ -209,4 +209,25 @@ export declare namespace Utils {
      * @param firstOnly Only convert the first word to upper case
      */
     const snakeNameToWord: (name: string, firstOnly?: boolean) => string;
+    /**
+     * Trim chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    const trim: (input: string, ...chars: string[]) => string;
+    /**
+     * Trim end chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    const trimEnd: (input: string, ...chars: string[]) => string;
+    /**
+     * Trim start chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    const trimStart: (input: string, ...chars: string[]) => string;
 }

package/lib/cjs/Utils.js

@@ -414,4 +414,38 @@ var Utils;
         }
         return items.map((part) => part.formatInitial(true)).join(' ');
     };
+    /**
+     * Trim chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    Utils.trim = (input, ...chars) => {
+        return Utils.trimEnd(Utils.trimStart(input, ...chars), ...chars);
+    };
+    /**
+     * Trim end chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    Utils.trimEnd = (input, ...chars) => {
+        let start = input.length - 1;
+        while (start >= 0 && chars.indexOf(input[start]) >= 0)
+            --start;
+        return input.substring(0, start + 1);
+    };
+    /**
+     * Trim start chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    Utils.trimStart = (input, ...chars) => {
+        let start = 0;
+        const end = input.length;
+        while (start < end && chars.indexOf(input[start]) >= 0)
+            ++start;
+        return input.substring(start);
+    };
 })(Utils = exports.Utils || (exports.Utils = {}));

package/lib/mjs/DataTypes.d.ts

@@ -183,6 +183,12 @@ export declare namespace DataTypes {
     type Keys<T extends object, R = string | number> = {
         [k in keyof T]: T[k] extends R ? k : never;
     }[keyof T];
+    /**
+     * Require at least one property of the keys
+     */
+    type RequireAtLeastOne<T, Keys extends keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+        [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+    }[Keys];
     /**
      * Culture definiton
      */

package/lib/mjs/Utils.d.ts

@@ -209,4 +209,25 @@ export declare namespace Utils {
      * @param firstOnly Only convert the first word to upper case
      */
     const snakeNameToWord: (name: string, firstOnly?: boolean) => string;
+    /**
+     * Trim chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    const trim: (input: string, ...chars: string[]) => string;
+    /**
+     * Trim end chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    const trimEnd: (input: string, ...chars: string[]) => string;
+    /**
+     * Trim start chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    const trimStart: (input: string, ...chars: string[]) => string;
 }

package/lib/mjs/Utils.js

@@ -411,4 +411,38 @@ export var Utils;
         }
         return items.map((part) => part.formatInitial(true)).join(' ');
     };
+    /**
+     * Trim chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    Utils.trim = (input, ...chars) => {
+        return Utils.trimEnd(Utils.trimStart(input, ...chars), ...chars);
+    };
+    /**
+     * Trim end chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    Utils.trimEnd = (input, ...chars) => {
+        let start = input.length - 1;
+        while (start >= 0 && chars.indexOf(input[start]) >= 0)
+            --start;
+        return input.substring(0, start + 1);
+    };
+    /**
+     * Trim start chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    Utils.trimStart = (input, ...chars) => {
+        let start = 0;
+        const end = input.length;
+        while (start < end && chars.indexOf(input[start]) >= 0)
+            ++start;
+        return input.substring(start);
+    };
 })(Utils || (Utils = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.1.55",
+    "version": "1.1.57",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -54,15 +54,15 @@
     },
     "homepage": "https://github.com/ETSOO/Shared#readme",
     "devDependencies": {
-        "@types/jest": "^29.0.0",
-        "@typescript-eslint/eslint-plugin": "^5.36.2",
-        "@typescript-eslint/parser": "^5.36.2",
-        "eslint": "^8.23.0",
+        "@types/jest": "^29.0.3",
+        "@typescript-eslint/eslint-plugin": "^5.37.0",
+        "@typescript-eslint/parser": "^5.37.0",
+        "eslint": "^8.23.1",
         "eslint-config-airbnb-base": "^15.0.0",
         "eslint-plugin-import": "^2.26.0",
         "jest": "^29.0.3",
         "jest-environment-jsdom": "^29.0.3",
-        "ts-jest": "^29.0.0",
+        "ts-jest": "^29.0.1",
         "typescript": "^4.8.3"
     }
 }

package/src/DataTypes.ts

@@ -235,6 +235,18 @@ export namespace DataTypes {
         [k in keyof T]: T[k] extends R ? k : never;
     }[keyof T];
 
+    /**
+     * Require at least one property of the keys
+     */
+    export type RequireAtLeastOne<T, Keys extends keyof T> = Pick<
+        T,
+        Exclude<keyof T, Keys>
+    > &
+        {
+            [K in Keys]-?: Required<Pick<T, K>> &
+                Partial<Pick<T, Exclude<Keys, K>>>;
+        }[Keys];
+
     /**
      * Culture definiton
      */

package/src/Utils.ts

@@ -572,4 +572,43 @@ export namespace Utils {
 
         return items.map((part) => part.formatInitial(true)).join(' ');
     };
+
+    /**
+     * Trim chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    export const trim = (input: string, ...chars: string[]) => {
+        return trimEnd(trimStart(input, ...chars), ...chars);
+    };
+
+    /**
+     * Trim end chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    export const trimEnd = (input: string, ...chars: string[]) => {
+        let start = input.length - 1;
+
+        while (start >= 0 && chars.indexOf(input[start]) >= 0) --start;
+
+        return input.substring(0, start + 1);
+    };
+
+    /**
+     * Trim start chars
+     * @param input Input string
+     * @param chars Trim chars
+     * @returns Result
+     */
+    export const trimStart = (input: string, ...chars: string[]) => {
+        let start = 0;
+        const end = input.length;
+
+        while (start < end && chars.indexOf(input[start]) >= 0) ++start;
+
+        return input.substring(start);
+    };
 }