@etsoo/shared 1.2.46 → 1.2.48

package/README.md

@@ -120,6 +120,8 @@ Data type definitions and type safe functions. ListItemType, ListItemType1 and L
 |DataType|Data type enum|
 |AddAndEditType|Add and edit data type|
 |AddOrEditType|Add or edit conditional type|
+|addUrlParam|Add parameter to URL|
+|addUrlParams|Add parameters to URL|
 |Basic|Basic types, includes number, bigint, Date, boolean, string|
 |BasicArray|Basic type name array|
 |BasicConditional|Conditional type based on BasicNames|

package/__tests__/Utils.ts

@@ -13,6 +13,54 @@ test('Tests for addBlankItem', () => {
     expect(options.length).toBe(3);
 });
 
+test('Tests for addUrlParam', () => {
+    const url = 'https://www.etsoo.com';
+    const result = url.addUrlParam('a', 'b');
+    expect(result).toBe('https://www.etsoo.com/?a=b');
+});
+
+describe('Tests for addUrlParams', () => {
+    const url = 'https://www.etsoo.com';
+    const data = {
+        a: 'a',
+        b: false,
+        c: 123,
+        d: new Date(Date.UTC(2022, 0, 28, 10)),
+        e: [1, 2],
+        f: ['a', 'b'],
+        g: null
+    };
+    const result1 = url.addUrlParams(data);
+
+    test('addUrlParams', () => {
+        expect(result1).toBe(
+            'https://www.etsoo.com/?a=a&b=false&c=123&d=2022-01-28T10%3A00%3A00.000Z&e=1&e=2&f=a&f=b&g='
+        );
+    });
+
+    const result2 = url.addUrlParams(data, true);
+
+    test('addUrlParams with array format', () => {
+        expect(result2).toBe(
+            'https://www.etsoo.com/?a=a&b=false&c=123&d=2022-01-28T10%3A00%3A00.000Z&e=1%2C2&f=a%2Cb&g='
+        );
+    });
+
+    global.URL = undefined as any;
+
+    const result3 = url.addUrlParams(data);
+
+    test('addUrlParams with traditional way', () => {
+        expect(result3).toBe(result1);
+    });
+
+    const result4 = url.addUrlParams(data, true);
+
+    test('addUrlParams with traditional way and array format', () => {
+        expect(result4).toBe(result2);
+    });
+});
+
 test('Tests for containChinese', () => {
     expect('123 abC'.containChinese()).toBeFalsy();
     expect('亿速思维'.containChinese()).toBeTruthy();

package/lib/cjs/Utils.d.ts

@@ -2,6 +2,30 @@ import { DataTypes, IdType } from './DataTypes';
 import { ParsedPath } from './types/ParsedPath';
 declare global {
     interface String {
+        /**
+         * Add parameter to URL
+         * @param this URL to add parameter
+         * @param name Parameter name
+         * @param value Parameter value
+         * @param arrayFormat Array format to array style or not to multiple fields
+         * @returns New URL
+         */
+        addUrlParam(this: string, name: string, value: DataTypes.Simple, arrayFormat?: boolean | string): string;
+        /**
+         * Add parameters to URL
+         * @param this URL to add parameters
+         * @param data Parameters
+         * @param arrayFormat Array format to array style or not to multiple fields
+         * @returns New URL
+         */
+        addUrlParams(this: string, data: DataTypes.SimpleObject, arrayFormat?: boolean | string): string;
+        /**
+         * Add parameters to URL
+         * @param this URL to add parameters
+         * @param params Parameters string
+         * @returns New URL
+         */
+        addUrlParams(this: string, params: string): string;
         /**
          * Check the input string contains Chinese character or not
          * @param this Input

package/lib/cjs/Utils.js

@@ -7,6 +7,70 @@ exports.Utils = void 0;
 const DataTypes_1 = require("./DataTypes");
 const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
 const DateUtils_1 = require("./DateUtils");
+String.prototype.addUrlParam = function (name, value, arrayFormat) {
+    return this.addUrlParams({ [name]: value }, arrayFormat);
+};
+String.prototype.addUrlParams = function (data, arrayFormat) {
+    if (typeof data === 'string') {
+        let url = this;
+        if (url.includes('?')) {
+            url += '&';
+        }
+        else {
+            if (!url.endsWith('/'))
+                url = url + '/';
+            url += '?';
+        }
+        return url + data;
+    }
+    if (typeof URL === 'undefined') {
+        const params = Object.entries(data)
+            .map(([key, value]) => {
+            let v;
+            if (Array.isArray(value)) {
+                if (arrayFormat == null || arrayFormat === false) {
+                    return value
+                        .map((item) => `${key}=${encodeURIComponent(`${item}`)}`)
+                        .join('&');
+                }
+                else {
+                    v = value.join(arrayFormat ? ',' : arrayFormat);
+                }
+            }
+            else if (value instanceof Date) {
+                v = value.toJSON();
+            }
+            else {
+                v = value == null ? '' : `${value}`;
+            }
+            return `${key}=${encodeURIComponent(v)}`;
+        })
+            .join('&');
+        return this.addUrlParams(params);
+    }
+    else {
+        const urlObj = new URL(this);
+        Object.entries(data).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                if (arrayFormat == null || arrayFormat === false) {
+                    value.forEach((item) => {
+                        urlObj.searchParams.append(key, `${item}`);
+                    });
+                }
+                else {
+                    urlObj.searchParams.append(key, value.join(arrayFormat ? ',' : arrayFormat));
+                }
+            }
+            else if (value instanceof Date) {
+                urlObj.searchParams.append(key, value.toJSON());
+            }
+            else {
+                urlObj.searchParams.append(key, `${value == null ? '' : value}`);
+            }
+        });
+        return urlObj.toString();
+    }
+};
 String.prototype.containChinese = function () {
     const regExp = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff66-\uff9f]/g;
     return regExp.test(this);

package/lib/mjs/Utils.d.ts

@@ -2,6 +2,30 @@ import { DataTypes, IdType } from './DataTypes';
 import { ParsedPath } from './types/ParsedPath';
 declare global {
     interface String {
+        /**
+         * Add parameter to URL
+         * @param this URL to add parameter
+         * @param name Parameter name
+         * @param value Parameter value
+         * @param arrayFormat Array format to array style or not to multiple fields
+         * @returns New URL
+         */
+        addUrlParam(this: string, name: string, value: DataTypes.Simple, arrayFormat?: boolean | string): string;
+        /**
+         * Add parameters to URL
+         * @param this URL to add parameters
+         * @param data Parameters
+         * @param arrayFormat Array format to array style or not to multiple fields
+         * @returns New URL
+         */
+        addUrlParams(this: string, data: DataTypes.SimpleObject, arrayFormat?: boolean | string): string;
+        /**
+         * Add parameters to URL
+         * @param this URL to add parameters
+         * @param params Parameters string
+         * @returns New URL
+         */
+        addUrlParams(this: string, params: string): string;
         /**
          * Check the input string contains Chinese character or not
          * @param this Input

package/lib/mjs/Utils.js

@@ -1,6 +1,70 @@
 import { DataTypes } from './DataTypes';
 import isEqual from 'lodash.isequal';
 import { DateUtils } from './DateUtils';
+String.prototype.addUrlParam = function (name, value, arrayFormat) {
+    return this.addUrlParams({ [name]: value }, arrayFormat);
+};
+String.prototype.addUrlParams = function (data, arrayFormat) {
+    if (typeof data === 'string') {
+        let url = this;
+        if (url.includes('?')) {
+            url += '&';
+        }
+        else {
+            if (!url.endsWith('/'))
+                url = url + '/';
+            url += '?';
+        }
+        return url + data;
+    }
+    if (typeof URL === 'undefined') {
+        const params = Object.entries(data)
+            .map(([key, value]) => {
+            let v;
+            if (Array.isArray(value)) {
+                if (arrayFormat == null || arrayFormat === false) {
+                    return value
+                        .map((item) => `${key}=${encodeURIComponent(`${item}`)}`)
+                        .join('&');
+                }
+                else {
+                    v = value.join(arrayFormat ? ',' : arrayFormat);
+                }
+            }
+            else if (value instanceof Date) {
+                v = value.toJSON();
+            }
+            else {
+                v = value == null ? '' : `${value}`;
+            }
+            return `${key}=${encodeURIComponent(v)}`;
+        })
+            .join('&');
+        return this.addUrlParams(params);
+    }
+    else {
+        const urlObj = new URL(this);
+        Object.entries(data).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                if (arrayFormat == null || arrayFormat === false) {
+                    value.forEach((item) => {
+                        urlObj.searchParams.append(key, `${item}`);
+                    });
+                }
+                else {
+                    urlObj.searchParams.append(key, value.join(arrayFormat ? ',' : arrayFormat));
+                }
+            }
+            else if (value instanceof Date) {
+                urlObj.searchParams.append(key, value.toJSON());
+            }
+            else {
+                urlObj.searchParams.append(key, `${value == null ? '' : value}`);
+            }
+        });
+        return urlObj.toString();
+    }
+};
 String.prototype.containChinese = function () {
     const regExp = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff66-\uff9f]/g;
     return regExp.test(this);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.2.46",
+    "version": "1.2.48",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -59,7 +59,7 @@
         "jest": "^29.7.0",
         "jest-environment-jsdom": "^29.7.0",
         "ts-jest": "^29.2.5",
-        "typescript": "^5.6.2"
+        "typescript": "^5.6.3"
     },
     "dependencies": {
         "lodash.isequal": "^4.5.0"

package/src/Utils.ts

@@ -5,6 +5,42 @@ import { ParsedPath } from './types/ParsedPath';
 
 declare global {
     interface String {
+        /**
+         * Add parameter to URL
+         * @param this URL to add parameter
+         * @param name Parameter name
+         * @param value Parameter value
+         * @param arrayFormat Array format to array style or not to multiple fields
+         * @returns New URL
+         */
+        addUrlParam(
+            this: string,
+            name: string,
+            value: DataTypes.Simple,
+            arrayFormat?: boolean | string
+        ): string;
+
+        /**
+         * Add parameters to URL
+         * @param this URL to add parameters
+         * @param data Parameters
+         * @param arrayFormat Array format to array style or not to multiple fields
+         * @returns New URL
+         */
+        addUrlParams(
+            this: string,
+            data: DataTypes.SimpleObject,
+            arrayFormat?: boolean | string
+        ): string;
+
+        /**
+         * Add parameters to URL
+         * @param this URL to add parameters
+         * @param params Parameters string
+         * @returns New URL
+         */
+        addUrlParams(this: string, params: string): string;
+
         /**
          * Check the input string contains Chinese character or not
          * @param this Input
@@ -74,6 +110,84 @@ declare global {
     }
 }
 
+String.prototype.addUrlParam = function (
+    this: string,
+    name: string,
+    value: DataTypes.Simple,
+    arrayFormat?: boolean | string
+) {
+    return this.addUrlParams({ [name]: value }, arrayFormat);
+};
+
+String.prototype.addUrlParams = function (
+    this: string,
+    data: DataTypes.SimpleObject | string,
+    arrayFormat?: boolean | string
+) {
+    if (typeof data === 'string') {
+        let url = this;
+        if (url.includes('?')) {
+            url += '&';
+        } else {
+            if (!url.endsWith('/')) url = url + '/';
+            url += '?';
+        }
+        return url + data;
+    }
+
+    if (typeof URL === 'undefined') {
+        const params = Object.entries(data)
+            .map(([key, value]) => {
+                let v: string;
+                if (Array.isArray(value)) {
+                    if (arrayFormat == null || arrayFormat === false) {
+                        return value
+                            .map(
+                                (item) =>
+                                    `${key}=${encodeURIComponent(`${item}`)}`
+                            )
+                            .join('&');
+                    } else {
+                        v = value.join(arrayFormat ? ',' : arrayFormat);
+                    }
+                } else if (value instanceof Date) {
+                    v = value.toJSON();
+                } else {
+                    v = value == null ? '' : `${value}`;
+                }
+
+                return `${key}=${encodeURIComponent(v)}`;
+            })
+            .join('&');
+
+        return this.addUrlParams(params);
+    } else {
+        const urlObj = new URL(this);
+        Object.entries(data).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                if (arrayFormat == null || arrayFormat === false) {
+                    value.forEach((item) => {
+                        urlObj.searchParams.append(key, `${item}`);
+                    });
+                } else {
+                    urlObj.searchParams.append(
+                        key,
+                        value.join(arrayFormat ? ',' : arrayFormat)
+                    );
+                }
+            } else if (value instanceof Date) {
+                urlObj.searchParams.append(key, value.toJSON());
+            } else {
+                urlObj.searchParams.append(
+                    key,
+                    `${value == null ? '' : value}`
+                );
+            }
+        });
+        return urlObj.toString();
+    }
+};
+
 String.prototype.containChinese = function (this: string): boolean {
     const regExp =
         /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff66-\uff9f]/g;