@etsoo/shared 1.2.72 → 1.2.74

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

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

@@ -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<const A extends true | false, const F = T extends object ? keyof T : never>(item: T | (F extends keyof T ? (A extends true ? T : T | T[F]) : T), add: A, idField?: F): Array<T>;
         /**
          * Make all items are unique
          * @param this Input array

package/lib/cjs/ArrayUtils.js

@@ -8,6 +8,32 @@ 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 as the type assertion is ready
+            // when add is true, item should be T, not a field value
+            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/ArrayUtils.d.ts

@@ -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<const A extends true | false, const F = T extends object ? keyof T : never>(item: T | (F extends keyof T ? (A extends true ? T : T | T[F]) : T), add: A, idField?: F): Array<T>;
         /**
          * Make all items are unique
          * @param this Input array

package/lib/mjs/ArrayUtils.js

@@ -2,6 +2,32 @@ 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 as the type assertion is ready
+            // when add is true, item should be T, not a field value
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etsoo/shared",
-  "version": "1.2.72",
+  "version": "1.2.74",
   "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,21 @@ 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<
+      const A extends true | false,
+      const F = T extends object ? keyof T : never
+    >(
+      item: T | (F extends keyof T ? (A extends true ? T : T | T[F]) : T),
+      add: A,
+      idField?: F
+    ): Array<T>;
+
     /**
      * Make all items are unique
      * @param this Input array
@@ -93,6 +108,41 @@ Array.prototype.different = function <T>(
   return ArrayUtils.differences(this, target, round);
 };
 
+Array.prototype.toggleItem = function <
+  T,
+  const A extends true | false,
+  const F = T extends object ? keyof T : never
+>(
+  this: Array<T>,
+  item: T | (F extends keyof T ? (A extends true ? T : T | T[F]) : T),
+  add: A,
+  idField?: F
+) {
+  const isObject = typeof item === "object" && item !== null;
+  const index = this.findIndex((i) => {
+    if (idField) {
+      if (isObject) {
+        return i[idField as keyof T] === (item as T)[idField as keyof T];
+      } else {
+        return i[idField as keyof T] === item;
+      }
+    }
+    return isEqual(i, item);
+  });
+
+  if (add) {
+    if (index < 0) {
+      // Ignore type checking as the type assertion is ready
+      // when add is true, item should be T, not a field value
+      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));