@etsoo/shared 1.2.71 → 1.2.73

package/README.md

@@ -122,6 +122,7 @@ Array related utilities
 |     minItem | Get min field value item                                     |
 |      remove | Remove items by value or condition                           |
 |         sum | Sum number items or number item properties                   |
+|  toggleItem | Toggle item in array                                         |
 |    toUnique | Make all items are unique                                    |
 
 ## DataTypes
@@ -276,6 +277,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__/ArrayUtils.ts

@@ -157,3 +157,39 @@ test("Tests for sortIds 2", () => {
     "SGD"
   ]);
 });
+
+test("Tests for toggleItem", () => {
+  const items = [1, 2, 3];
+  items.toggleItem(2, false);
+  expect(items).toStrictEqual([1, 3]);
+
+  items.toggleItem(4, true);
+  expect(items).toStrictEqual([1, 3, 4]);
+
+  items.toggleItem(1, false);
+  expect(items).toStrictEqual([3, 4]);
+
+  items.toggleItem(3, true);
+  expect(items).toStrictEqual([3, 4]);
+});
+
+test("Tests for toggleItem with object", () => {
+  const items = [
+    { id: 1, label: "a" },
+    { id: 2, label: "b" }
+  ];
+  items.toggleItem({ id: 2, label: "b" }, false);
+  expect(items).toStrictEqual([{ id: 1, label: "a" }]);
+
+  items.toggleItem({ id: 3, label: "c" }, true, "id");
+  expect(items).toStrictEqual([
+    { id: 1, label: "a" },
+    { id: 3, label: "c" }
+  ]);
+
+  items.toggleItem(1, false, "id");
+  expect(items).toStrictEqual([{ id: 3, label: "c" }]);
+
+  items.toggleItem({ id: 3, label: "c" }, true, "id");
+  expect(items).toStrictEqual([{ id: 3, label: "c" }]);
+});

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/ArrayUtils.d.ts

@@ -1,4 +1,4 @@
-import { DataTypes } from "./DataTypes";
+import { DataTypes, IdType } from "./DataTypes";
 declare global {
     interface Array<T> {
         /**
@@ -43,6 +43,13 @@ declare global {
          * @param field Object field to calculate
          */
         sum(...field: T extends number ? [undefined?] : T extends object ? [DataTypes.Keys<T, number>] : [never]): number;
+        /**
+         * Toggle item in array
+         * @param item Item to toggle
+         * @param add If true, add the item, otherwise remove it
+         * @param idField If item is an object, use this field to check for existence
+         */
+        toggleItem(item: T extends object ? T | IdType : T, add: boolean, idField?: T extends object ? keyof T : never): Array<T>;
         /**
          * Make all items are unique
          * @param this Input array

package/lib/cjs/ArrayUtils.js

@@ -8,6 +8,31 @@ const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
 Array.prototype.different = function (target, round) {
     return ArrayUtils.differences(this, target, round);
 };
+Array.prototype.toggleItem = function (item, add, idField) {
+    const isObject = typeof item === "object" && item !== null;
+    const index = this.findIndex((i) => {
+        if (idField) {
+            if (isObject) {
+                return i[idField] === item[idField];
+            }
+            else {
+                return i[idField] === item;
+            }
+        }
+        return (0, lodash_isequal_1.default)(i, item);
+    });
+    if (add) {
+        if (index < 0) {
+            // Ignore type checking
+            this.push(item);
+        }
+    }
+    else {
+        if (index >= 0)
+            this.splice(index, 1);
+    }
+    return this;
+};
 Array.prototype.toUnique = function () {
     if (this.length === 0 || typeof this[0] !== "object")
         return Array.from(new Set(this));

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/ArrayUtils.d.ts

@@ -1,4 +1,4 @@
-import { DataTypes } from "./DataTypes";
+import { DataTypes, IdType } from "./DataTypes";
 declare global {
     interface Array<T> {
         /**
@@ -43,6 +43,13 @@ declare global {
          * @param field Object field to calculate
          */
         sum(...field: T extends number ? [undefined?] : T extends object ? [DataTypes.Keys<T, number>] : [never]): number;
+        /**
+         * Toggle item in array
+         * @param item Item to toggle
+         * @param add If true, add the item, otherwise remove it
+         * @param idField If item is an object, use this field to check for existence
+         */
+        toggleItem(item: T extends object ? T | IdType : T, add: boolean, idField?: T extends object ? keyof T : never): Array<T>;
         /**
          * Make all items are unique
          * @param this Input array

package/lib/mjs/ArrayUtils.js

@@ -2,6 +2,31 @@ import isEqual from "lodash.isequal";
 Array.prototype.different = function (target, round) {
     return ArrayUtils.differences(this, target, round);
 };
+Array.prototype.toggleItem = function (item, add, idField) {
+    const isObject = typeof item === "object" && item !== null;
+    const index = this.findIndex((i) => {
+        if (idField) {
+            if (isObject) {
+                return i[idField] === item[idField];
+            }
+            else {
+                return i[idField] === item;
+            }
+        }
+        return isEqual(i, item);
+    });
+    if (add) {
+        if (index < 0) {
+            // Ignore type checking
+            this.push(item);
+        }
+    }
+    else {
+        if (index >= 0)
+            this.splice(index, 1);
+    }
+    return this;
+};
 Array.prototype.toUnique = function () {
     if (this.length === 0 || typeof this[0] !== "object")
         return Array.from(new Set(this));

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.71",
+  "version": "1.2.73",
   "description": "TypeScript shared utilities and functions",
   "main": "lib/cjs/index.js",
   "module": "lib/mjs/index.js",
@@ -37,10 +37,10 @@
   "homepage": "https://github.com/ETSOO/Shared#readme",
   "devDependencies": {
     "@types/lodash.isequal": "^4.5.8",
-    "@vitejs/plugin-react": "^4.4.1",
+    "@vitejs/plugin-react": "^4.5.0",
     "jsdom": "^26.1.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
+    "vitest": "^3.1.4"
   },
   "dependencies": {
     "lodash.isequal": "^4.5.0"

package/src/ArrayUtils.ts

@@ -1,5 +1,5 @@
 import isEqual from "lodash.isequal";
-import { DataTypes } from "./DataTypes";
+import { DataTypes, IdType } from "./DataTypes";
 
 declare global {
   interface Array<T> {
@@ -77,6 +77,18 @@ declare global {
         : [never]
     ): number;
 
+    /**
+     * Toggle item in array
+     * @param item Item to toggle
+     * @param add If true, add the item, otherwise remove it
+     * @param idField If item is an object, use this field to check for existence
+     */
+    toggleItem(
+      item: T extends object ? T | IdType : T,
+      add: boolean,
+      idField?: T extends object ? keyof T : never
+    ): Array<T>;
+
     /**
      * Make all items are unique
      * @param this Input array
@@ -93,6 +105,36 @@ Array.prototype.different = function <T>(
   return ArrayUtils.differences(this, target, round);
 };
 
+Array.prototype.toggleItem = function <T>(
+  this: Array<T>,
+  item: T extends object ? T | IdType : T,
+  add: boolean,
+  idField?: T extends object ? keyof T : never
+) {
+  const isObject = typeof item === "object" && item !== null;
+  const index = this.findIndex((i) => {
+    if (idField) {
+      if (isObject) {
+        return i[idField] === (item as any)[idField];
+      } else {
+        return i[idField] === item;
+      }
+    }
+    return isEqual(i, item);
+  });
+
+  if (add) {
+    if (index < 0) {
+      // Ignore type checking
+      this.push(item as T);
+    }
+  } else {
+    if (index >= 0) this.splice(index, 1);
+  }
+
+  return this;
+};
+
 Array.prototype.toUnique = function <T>(this: Array<T>) {
   if (this.length === 0 || typeof this[0] !== "object")
     return Array.from(new Set(this));

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