feat: bump version to 0.6.0 and add omit utility

Updates package version to 0.6.0 in jsr.json and package.json. Introduces the `omit` utility function in the library and updates README with usage examples.

Author: sillvva

README.md

@@ -107,6 +107,22 @@ function checkFruits(fruit: string) {
 }
 ```
 
+### Omit
+
+```typescript
+import { omit } from "@sillvva/utils";
+
+const user = { id: 1, name: "Jane", email: "jane@example.com" };
+const safe = omit(user, ["email"]);
+console.log(safe); // { id: 1, name: "Jane" }
+
+// Strongly typed keys
+type User = { id: number; name: string; email: string };
+const u: User = { id: 1, name: "Jane", email: "jane@example.com" };
+const withoutEmail = omit(u, ["email"] as const);
+// withoutEmail is typed as { id: number; name: string }
+```
+
 ### Slugify
 
 ```typescript

jsr.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sillvva/utils",
-	"version": "0.5.7",
+	"version": "0.6.0",
 	"exports": {
 		".": "./src/entry.ts"
 	},

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sillvva/utils",
-	"version": "0.5.7",
+	"version": "0.6.0",
 	"description": "A module containing general purpose utility functions and types.",
 	"author": "Matt DeKok",
 	"license": "MIT",

src/entry.ts

@@ -3,6 +3,7 @@ export * from "./debounce";
 export * from "./isDefined";
 export * from "./isInstanceOfClass";
 export * from "./isOneOf";
+export * from "./omit";
 export * from "./slugify";
 export * from "./sorter";
 export * from "./substrCount";

src/omit.test.ts

@@ -0,0 +1,41 @@
+import { omit } from "./omit";
+
+describe("omit", () => {
+	it("omits specified keys from a simple object", () => {
+		const obj = { a: 1, b: 2, c: 3 };
+		const result = omit(obj, ["b"] as const);
+		expect(result).toEqual({ a: 1, c: 3 });
+	});
+
+	it("returns a new object and does not mutate the source", () => {
+		const obj = { a: 1, b: 2 } as const;
+		const result = omit(obj, ["a"] as const);
+		expect(result).toEqual({ b: 2 });
+		expect(obj).toEqual({ a: 1, b: 2 });
+		expect(result).not.toBe(obj);
+	});
+
+	it("works with empty keys list", () => {
+		const obj = { a: 1, b: 2 };
+		const result = omit(obj, [] as const);
+		expect(result).toEqual({ a: 1, b: 2 });
+	});
+
+	it("ignores keys that are not present on the object", () => {
+		const obj: Record<string, number> = { a: 1 };
+		const result = omit(obj, ["b"] as const);
+		expect(result).toEqual({ a: 1 });
+	});
+
+	it("handles symbol keys by preserving them when not omitted", () => {
+		const sym = Symbol("x");
+		// Our omit implementation uses Object.entries, which enumerates string keys.
+		// This test documents current behavior: symbol-keyed properties are preserved
+		// when not omitted and are also preserved when omitted since they are not enumerated.
+		const obj = { a: 1, [sym]: 2 } as Record<PropertyKey, unknown> as { a: number } & { [k: symbol]: number };
+		const result = omit(obj as { a: number }, ["a"] as const);
+		expect("a" in result).toBe(false);
+		// The symbol property remains untouched on the original object
+		expect((obj as any)[sym]).toBe(2);
+	});
+});

src/omit.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a shallow copy of an object without the specified keys.
+ *
+ * This function returns a new object composed of all properties from `obj`
+ * whose keys are not present in `keys`.
+ *
+ * @typeParam T - The source object type.
+ * @typeParam K - A readonly tuple/array of keys from `T` to omit.
+ * @param obj - The source object.
+ * @param keys - The keys to exclude from the resulting object.
+ * @returns A new object with the provided keys omitted.
+ *
+ * @example
+ * const user = { id: 1, name: "Jane", email: "jane@example.com" };
+ * const safe = omit(user, ["email"]);
+ * // Result: { id: 1, name: "Jane" }
+ */
+export function omit<T extends object, K extends readonly (keyof T)[]>(obj: T, keys: K): Omit<T, K[number]> {
+	const set = new Set<keyof T>(keys);
+	return Object.fromEntries(Object.entries(obj as Record<string, unknown>).filter(([k]) => !set.has(k as keyof T))) as Omit<T, K[number]>;
+}