@etsoo/shared 1.2.70 → 1.2.72

package/README.md

@@ -197,6 +197,7 @@ Data type definitions and type safe functions. ListItemType, ListItemType1 and L
 |      isSimpleObject | Is the target a simple object, all values are simple type (Type guard) |
 |        isSimpleType | Is the input value simple type, include null and undefined             |
 |        jsonReplacer | JSON.stringify replacer with full path                                 |
+|       jsonSerialize | JSON serialize with options                                            |
 
 ## DateUtils
 
@@ -275,6 +276,7 @@ Numbers related utilities
 | getCurrencySymbol | Get currency symbol or name from ISO code             |
 |             parse | Parse to number, with or without default value        |
 |           toExact | To the exact precision number avoiding precision lost |
+|            toStep | To the step number, like 0, 10, 20, 30 for step 10    |
 
 ## StorageUtils
 

package/__tests__/DataTypes.ts

@@ -202,6 +202,26 @@ test("Tests for jsonReplacer", () => {
   expect(json2).toBe('{"c":{"c2":false}}');
 });
 
+test("Tests for jsonSerialize", () => {
+  const obj = { a: 1, b: null, c: { c1: undefined, c2: false, c3: 128 } };
+  const json = DataTypes.jsonSerialize(obj);
+  expect(json).toBe('{"a":1,"c":{"c2":false,"c3":128}}');
+});
+
+test("Tests for jsonSerialize with removing empty values", () => {
+  const obj = {
+    a: 1,
+    b: null,
+    c: { c1: undefined, c2: false, c3: 128, c4: "" },
+    d: ""
+  };
+  const json = DataTypes.jsonSerialize(obj, {
+    ignoreEmpty: true,
+    ignoreNull: false
+  });
+  expect(json).toBe('{"a":1,"b":null,"c":{"c2":false,"c3":128}}');
+});
+
 test("Tests for EditType", () => {
   type AddEntity = {
     name: string;

package/__tests__/NumberUtils.ts

@@ -50,3 +50,12 @@ test("Tests for toFileSize", () => {
   expect(NumberUtils.formatFileSize(1125000)).toBe("1.07 MB");
   expect(NumberUtils.formatFileSize(1125000, 1)).toBe("1.1 MB");
 });
+
+test("Tests for toStep", () => {
+  const nums = [9, 13, 20, 33, 99, 101, 3009];
+  const results = nums.map((num) => num.toStep(10));
+  expect(results).toStrictEqual([0, 10, 20, 30, 90, 100, 3000]);
+
+  const results2 = nums.map((num) => num.toStep(8));
+  expect(results2).toStrictEqual([8, 8, 16, 32, 96, 96, 3008]);
+});

package/lib/cjs/DataTypes.d.ts

@@ -420,6 +420,16 @@ export declare namespace DataTypes {
      * @returns JSON receiver function
      */
     function jsonBigintReceiver(...args: string[]): (this: any, key: any, value: any) => any;
+    /**
+     * JSON serialize with options
+     * @param obj Object to serialize
+     * @param options Options to ignore null or empty values
+     * @returns Result
+     */
+    function jsonSerialize(obj: unknown, options?: {
+        ignoreNull?: boolean;
+        ignoreEmpty?: boolean;
+    }): string;
 }
 /**
  * Number and string combination id type

package/lib/cjs/DataTypes.js

@@ -498,4 +498,21 @@ var DataTypes;
         });
     }
     DataTypes.jsonBigintReceiver = jsonBigintReceiver;
+    /**
+     * JSON serialize with options
+     * @param obj Object to serialize
+     * @param options Options to ignore null or empty values
+     * @returns Result
+     */
+    function jsonSerialize(obj, options) {
+        const { ignoreNull = true, ignoreEmpty = false } = options ?? {};
+        return JSON.stringify(obj, (_key, value) => {
+            if (ignoreNull && value == null)
+                return undefined;
+            if (ignoreEmpty && value === "")
+                return undefined;
+            return value;
+        });
+    }
+    DataTypes.jsonSerialize = jsonSerialize;
 })(DataTypes || (exports.DataTypes = DataTypes = {}));

package/lib/cjs/NumberUtils.d.ts

@@ -5,6 +5,11 @@ declare global {
          * @param precision Precision
          */
         toExact(precision?: number): number;
+        /**
+         * To the step number, like 0, 10, 20, 30 for step 10
+         * @param step Step
+         */
+        toStep(step: number): number;
     }
 }
 export declare namespace NumberUtils {

package/lib/cjs/NumberUtils.js

@@ -9,6 +9,11 @@ Number.prototype.toExact = function (precision) {
     const p = Math.pow(10, precision);
     return Math.round(this * p) / p;
 };
+Number.prototype.toStep = function (step) {
+    if (step <= 0)
+        return this;
+    return Math.floor(this / step) * step;
+};
 var NumberUtils;
 (function (NumberUtils) {
     /**

package/lib/mjs/DataTypes.d.ts

@@ -420,6 +420,16 @@ export declare namespace DataTypes {
      * @returns JSON receiver function
      */
     function jsonBigintReceiver(...args: string[]): (this: any, key: any, value: any) => any;
+    /**
+     * JSON serialize with options
+     * @param obj Object to serialize
+     * @param options Options to ignore null or empty values
+     * @returns Result
+     */
+    function jsonSerialize(obj: unknown, options?: {
+        ignoreNull?: boolean;
+        ignoreEmpty?: boolean;
+    }): string;
 }
 /**
  * Number and string combination id type

package/lib/mjs/DataTypes.js

@@ -495,4 +495,21 @@ export var DataTypes;
         });
     }
     DataTypes.jsonBigintReceiver = jsonBigintReceiver;
+    /**
+     * JSON serialize with options
+     * @param obj Object to serialize
+     * @param options Options to ignore null or empty values
+     * @returns Result
+     */
+    function jsonSerialize(obj, options) {
+        const { ignoreNull = true, ignoreEmpty = false } = options ?? {};
+        return JSON.stringify(obj, (_key, value) => {
+            if (ignoreNull && value == null)
+                return undefined;
+            if (ignoreEmpty && value === "")
+                return undefined;
+            return value;
+        });
+    }
+    DataTypes.jsonSerialize = jsonSerialize;
 })(DataTypes || (DataTypes = {}));

package/lib/mjs/NumberUtils.d.ts

@@ -5,6 +5,11 @@ declare global {
          * @param precision Precision
          */
         toExact(precision?: number): number;
+        /**
+         * To the step number, like 0, 10, 20, 30 for step 10
+         * @param step Step
+         */
+        toStep(step: number): number;
     }
 }
 export declare namespace NumberUtils {

package/lib/mjs/NumberUtils.js

@@ -6,6 +6,11 @@ Number.prototype.toExact = function (precision) {
     const p = Math.pow(10, precision);
     return Math.round(this * p) / p;
 };
+Number.prototype.toStep = function (step) {
+    if (step <= 0)
+        return this;
+    return Math.floor(this / step) * step;
+};
 export var NumberUtils;
 (function (NumberUtils) {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etsoo/shared",
-  "version": "1.2.70",
+  "version": "1.2.72",
   "description": "TypeScript shared utilities and functions",
   "main": "lib/cjs/index.js",
   "module": "lib/mjs/index.js",
@@ -40,7 +40,7 @@
     "@vitejs/plugin-react": "^4.4.1",
     "jsdom": "^26.1.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2"
+    "vitest": "^3.1.3"
   },
   "dependencies": {
     "lodash.isequal": "^4.5.0"

package/src/DataTypes.ts

@@ -800,6 +800,25 @@ export namespace DataTypes {
       return value;
     });
   }
+
+  /**
+   * JSON serialize with options
+   * @param obj Object to serialize
+   * @param options Options to ignore null or empty values
+   * @returns Result
+   */
+  export function jsonSerialize(
+    obj: unknown,
+    options?: { ignoreNull?: boolean; ignoreEmpty?: boolean }
+  ) {
+    const { ignoreNull = true, ignoreEmpty = false } = options ?? {};
+
+    return JSON.stringify(obj, (_key, value) => {
+      if (ignoreNull && value == null) return undefined;
+      if (ignoreEmpty && value === "") return undefined;
+      return value;
+    });
+  }
 }
 
 /**

package/src/NumberUtils.ts

@@ -5,6 +5,12 @@ declare global {
      * @param precision Precision
      */
     toExact(precision?: number): number;
+
+    /**
+     * To the step number, like 0, 10, 20, 30 for step 10
+     * @param step Step
+     */
+    toStep(step: number): number;
   }
 }
 
@@ -17,6 +23,12 @@ Number.prototype.toExact = function (this: number, precision?: number) {
   return Math.round(this * p) / p;
 };
 
+Number.prototype.toStep = function (this: number, step: number) {
+  if (step <= 0) return this;
+
+  return Math.floor(this / step) * step;
+};
+
 export namespace NumberUtils {
   /**
    * Format number