Add hasKey and omit utility functions to ObjectUtils

USAGE.md

@@ -76,8 +76,10 @@ Here are some of the utility functions and classes available in this library:
   - [deepClone](#deepclone)
   - [pick](#pick)
   - [keys](#keys)
+  - [hasKey](#haskey)
   - [values](#values)
   - [merge](#merge)
+  - [omit](#omit)
 
 - [StringUtils](#stringutils)
   - [capitalize](#capitalize)
@@ -760,6 +762,18 @@ the following utility functions are available in the `ObjectUtils` class, they c
 ```
 
 
+### hasKey
+```typescript
+/**
+ * Checks if an object has a specific key.
+ *
+ * @param obj - The object to check.
+ * @param key - The key to check for.
+ * @returns A boolean indicating whether the object has the specified key.
+*/
+```
+
+
 ### values
 ```typescript
 /**
@@ -785,6 +799,18 @@ the following utility functions are available in the `ObjectUtils` class, they c
 ```
 
 
+### omit
+```typescript
+/**
+ * Creates a new object with the specified keys omitted.
+ *
+ * @param obj - The object from which to omit keys.
+ * @param keys - An array of keys to omit from the object.
+ * @returns A new object with the specified keys omitted.
+*/
+```
+
+
 
 ## StringUtils
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typelegend",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "module": "dist/index.mjs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/object/hasKey.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks if an object has a specific key.
+ *
+ * @param obj - The object to check.
+ * @param key - The key to check for.
+ * @returns A boolean indicating whether the object has the specified key.
+ */
+export function hasKey(obj: object, key: string): boolean {
+  return Object.hasOwn(obj, key);
+}

src/object/index.ts

@@ -2,20 +2,26 @@
 import { deepClone } from "./deepClone";
 import { pick } from "./pick";
 import { keys } from "./keys";
+import { hasKey } from "./hasKey";
 import { values } from "./values";
 import { merge } from "./merge";
+import { omit } from "./omit";
 
 export class ObjectUtils {
   static deepClone: typeof deepClone = deepClone;
   static pick: typeof pick = pick;
   static keys: typeof keys = keys;
+  static hasKey: typeof hasKey = hasKey;
   static values: typeof values = values;
   static merge: typeof merge = merge;
+  static omit: typeof omit = omit;
 }
 
 export { deepClone } from "./deepClone";
 export { pick } from "./pick";
 export { keys } from "./keys";
+export { hasKey } from "./hasKey";
 export { values } from "./values";
 export { merge } from "./merge";
+export { omit } from "./omit";
 

src/object/omit.ts

@@ -0,0 +1,18 @@
+/**
+ * Creates a new object with the specified keys omitted.
+ *
+ * @param obj - The object from which to omit keys.
+ * @param keys - An array of keys to omit from the object.
+ * @returns A new object with the specified keys omitted.
+ */
+export function omit(obj: object, keys: string[]): object {
+  if (keys.length === 0) {
+    return obj;
+  }
+
+  const result: { [key: string]: any } = { ...obj };
+  keys.forEach((key) => {
+    delete result[key];
+  });
+  return result;
+}

test/object/hasKey.test.ts

@@ -0,0 +1,22 @@
+import { expect, describe, it } from "bun:test";
+import { hasKey } from "../../src/object/hasKey";
+
+describe("hasKey", () => {
+  it("should return true if the object has the specified key", () => {
+    const obj = { name: "John", age: 30 };
+    expect(hasKey(obj, "name")).toBe(true);
+    expect(hasKey(obj, "age")).toBe(true);
+  });
+
+  it("should return false if the object does not have the specified key", () => {
+    const obj = { name: "John", age: 30 };
+    expect(hasKey(obj, "email")).toBe(false);
+    expect(hasKey(obj, "address")).toBe(false);
+  });
+
+  it("should return false if the object is empty", () => {
+    const obj = {};
+    expect(hasKey(obj, "name")).toBe(false);
+    expect(hasKey(obj, "age")).toBe(false);
+  });
+});

test/object/omit.test.ts

@@ -0,0 +1,32 @@
+import { expect, describe, it } from "bun:test";
+import { omit } from "../../src/object/omit";
+
+describe("omit", () => {
+  it("should return a new object with specified keys omitted", () => {
+    const obj = { a: 1, b: 2, c: 3, d: 4 };
+    const keys = ["b", "d"];
+    const result = omit(obj, keys);
+    expect(result).toEqual({ a: 1, c: 3 });
+  });
+
+  it("should not modify the original object", () => {
+    const obj = { a: 1, b: 2, c: 3, d: 4 };
+    const keys = ["b", "d"];
+    omit(obj, keys);
+    expect(obj).toEqual({ a: 1, b: 2, c: 3, d: 4 });
+  });
+
+  it("should return the same object when no keys are specified", () => {
+    const obj = { a: 1, b: 2, c: 3, d: 4 };
+    const keys: string[] = [];
+    const result = omit(obj, keys);
+    expect(result).toBe(obj);
+  });
+
+  it("should return an empty object when all keys are specified", () => {
+    const obj = { a: 1, b: 2, c: 3, d: 4 };
+    const keys = ["a", "b", "c", "d"];
+    const result = omit(obj, keys);
+    expect(result).toEqual({});
+  });
+});