umsizi 0.2.2 → 0.3.0

package/README.md

@@ -117,6 +117,114 @@ const value = identity("umsizi");
 
 ```
 
+#### `typedKeys`
+
+```ts
+import { typedKeys } from "umsizi";
+
+const user = { id: "1", name: "Jack" } as const;
+
+typedKeys(user);
+// ["id", "name"]
+```
+
+#### `typedEntries`
+
+```ts
+import { typedEntries } from "umsizi";
+
+const user = { id: "1", active: true } as const;
+
+typedEntries(user);
+// [["id", "1"], ["active", true]]
+```
+
+#### `typedFromEntries`
+
+```ts
+import { typedFromEntries } from "umsizi";
+
+const user = typedFromEntries([
+	["id", "1"],
+	["active", true],
+] as const);
+```
+
+#### `pick`
+
+```ts
+import { pick } from "umsizi";
+
+pick({ id: "1", name: "Jack", role: "admin" }, "id", "role");
+// { id: "1", role: "admin" }
+```
+
+#### `omit`
+
+```ts
+import { omit } from "umsizi";
+
+omit({ id: "1", name: "Jack", role: "admin" }, "role");
+// { id: "1", name: "Jack" }
+```
+
+For the best autocomplete, prefer the rest-key form for `pick()` and `omit()`.
+If you pass an array literal and want exact key inference, use `as const`:
+
+```ts
+pick(user, ["id", "role"] as const);
+omit(user, ["createdAt"] as const);
+```
+
+#### `isEmpty`
+
+```ts
+import { isEmpty } from "umsizi";
+
+isEmpty({});
+// true
+```
+
+#### `hasOwn`
+
+```ts
+import { hasOwn } from "umsizi";
+
+const user = { id: "1" };
+const key: string = "id";
+
+if (hasOwn(user, key)) {
+	user[key];
+}
+```
+
+#### `mapValues`
+
+```ts
+import { mapValues } from "umsizi";
+
+mapValues({ draft: 1, published: 2 }, (value) => value * 2);
+// { draft: 2, published: 4 }
+```
+
+#### `filterValues`
+
+```ts
+import { filterValues } from "umsizi";
+
+filterValues({ a: 1, b: 0, c: null }, (value) => value !== null);
+// { a: 1, b: 0 }
+```
+
+#### `compactObject`
+
+```ts
+import { compactObject } from "umsizi";
+
+compactObject({ id: "1", nickname: null, active: false });
+// { id: "1", active: false }
+```
+
 ### React Utilities (`umsizi/react`)
 
 #### `isRenderFunction`

package/dist/index.d.ts

@@ -2,8 +2,73 @@ import { t as normalizePathname } from "./index-rZiv1o95.js";
 import { t as hasFileExtension } from "./index-DtjbEW43.js";
 import { t as isRenderFunction } from "./index-dktuz4mv.js";
 
+//#region src/core/types.d.ts
+type StringKeyOf<T extends object> = Extract<keyof T, string>;
+type ObjectEntry<T extends object> = { [K in StringKeyOf<T>]: readonly [K, T[K]] }[StringKeyOf<T>];
+type ObjectEntries<T extends object> = Array<ObjectEntry<T>>;
+type EntryTuple = readonly [PropertyKey, unknown];
+type EntryTuples = ReadonlyArray<EntryTuple>;
+type ObjectFromEntries<T extends EntryTuples> = { [K in T[number] as K[0]]: K[1] };
+type ValueMapper<T extends object, R> = (value: T[StringKeyOf<T>], key: StringKeyOf<T>, object: T) => R;
+type ValuePredicate<T extends object> = (value: T[StringKeyOf<T>], key: StringKeyOf<T>, object: T) => boolean;
+type ValueGuard<T extends object, S extends T[StringKeyOf<T>]> = (value: T[StringKeyOf<T>], key: StringKeyOf<T>, object: T) => value is S;
+type MappedValues<T extends object, R> = { [K in StringKeyOf<T>]: R };
+type FilteredValues<T extends object, S extends T[StringKeyOf<T>]> = Partial<{ [K in StringKeyOf<T>]: Extract<T[K], S> }>;
+type CompactedObject<T extends object> = Partial<{ [K in StringKeyOf<T>]: Exclude<T[K], null | undefined> }>;
+//#endregion
+//#region src/core/compact-object.d.ts
+/**
+ * Creates a new object with all `null` and `undefined` values removed.
+ *
+ * Other falsy values such as `0`, `false`, `""`, and `NaN` are preserved.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", nickname: null, active: false } as const;
+ *
+ * compactObject(user); // { id: "1", active: false }
+ * ```
+ */
+declare function compactObject<T extends object>(object: T): CompactedObject<T>;
+//#endregion
+//#region src/core/filter-values.d.ts
+/**
+ * Filters an object's own enumerable string-keyed properties by value.
+ *
+ * Supports both boolean predicates and type-guard predicates. The result type
+ * remains partial because any property may be removed at runtime.
+ *
+ * @example
+ * ```ts
+ * const settings = { retries: 3, label: "", timeout: null } as const;
+ *
+ * filterValues(settings, (value) => value !== null);
+ * // { retries: 3, label: "" }
+ * ```
+ */
+declare function filterValues<T extends object, S extends T[Extract<keyof T, string>]>(object: T, predicate: ValueGuard<T, S>): FilteredValues<T, S>;
+declare function filterValues<T extends object>(object: T, predicate: ValuePredicate<T>): FilteredValues<T, T[Extract<keyof T, string>]>;
+//#endregion
+//#region src/core/has-own.d.ts
+/**
+ * Checks whether an object has the given property as its own key.
+ *
+ * This is a typed wrapper around `Object.hasOwn` that narrows the provided key
+ * when the check succeeds.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1" };
+ * const key: string = "id";
+ *
+ * if (hasOwn(user, key)) {
+ *   user[key]; // key is narrowed to "id"
+ * }
+ * ```
+ */
+declare function hasOwn<T extends object, K$1 extends PropertyKey>(object: T, key: K$1): key is Extract<K$1, keyof T>;
+//#endregion
 //#region src/core/identity.d.ts
-
 /**
  * Returns the given value unchanged.
  *
@@ -17,5 +82,121 @@ import { t as isRenderFunction } from "./index-dktuz4mv.js";
  */
 declare function identity<T>(value: T): T;
 //#endregion
-export { hasFileExtension, identity, isRenderFunction, normalizePathname };
+//#region src/core/is-empty.d.ts
+/**
+ * Returns `true` when an object has no own enumerable properties.
+ *
+ * Both string keys and symbol keys are considered. Non-enumerable properties
+ * are ignored.
+ *
+ * @example
+ * ```ts
+ * isEmpty({}); // true
+ * isEmpty({ id: "1" }); // false
+ * ```
+ */
+declare function isEmpty(object: object): boolean;
+//#endregion
+//#region src/core/map-values.d.ts
+/**
+ * Maps the values of an object's own enumerable string-keyed properties while
+ * preserving the original enumerable string-key set.
+ *
+ * @example
+ * ```ts
+ * const counts = { draft: 1, published: 2 };
+ *
+ * mapValues(counts, (value) => value * 2);
+ * // { draft: 2, published: 4 }
+ * ```
+ */
+declare function mapValues<T extends object, R>(object: T, mapper: ValueMapper<T, R>): MappedValues<T, R>;
+//#endregion
+//#region src/core/omit.d.ts
+/**
+ * Creates a new object excluding the selected own enumerable properties.
+ *
+ * Prefer the rest-key form for the strongest autocomplete and inference.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", name: "Umsizi", role: "admin" } as const;
+ *
+ * omit(user, "id", "name"); // { role: "admin" }
+ * omit(user, ["role"] as const); // { id: "1", name: "Umsizi" }
+ * ```
+ */
+declare function omit<T extends object, const Keys extends readonly (keyof T)[]>(object: T, ...keys: Keys): Omit<T, Keys[number]>;
+declare function omit<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(object: T, keys: readonly [FirstKey, ...RestKeys]): Omit<T, FirstKey | RestKeys[number]>;
+declare function omit<T extends object>(object: T, keys: readonly (keyof T)[]): Partial<T>;
+//#endregion
+//#region src/core/pick.d.ts
+/**
+ * Creates a new object containing only the selected own properties.
+ *
+ * Prefer the rest-key form for the strongest autocomplete and inference.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", name: "Umsizi", role: "admin" } as const;
+ *
+ * pick(user, "name"); // { name: "Umsizi" }
+ * pick(user, ["id", "role"] as const); // { id: "1", role: "admin" }
+ * ```
+ */
+declare function pick<T extends object, const Keys extends readonly (keyof T)[]>(object: T, ...keys: Keys): Pick<T, Keys[number]>;
+declare function pick<T extends object, const FirstKey extends keyof T, const RestKeys extends readonly (keyof T)[]>(object: T, keys: readonly [FirstKey, ...RestKeys]): Pick<T, FirstKey | RestKeys[number]>;
+declare function pick<T extends object>(object: T, keys: readonly (keyof T)[]): Partial<T>;
+//#endregion
+//#region src/core/typed-entries.d.ts
+/**
+ * Returns the own enumerable string-keyed entries of an object with preserved
+ * key/value pairing.
+ *
+ * This is a typed wrapper around `Object.entries`.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", active: true } as const;
+ *
+ * typedEntries(user); // [["id", "1"], ["active", true]]
+ * ```
+ */
+declare function typedEntries<T extends object>(object: T): ObjectEntries<T>;
+//#endregion
+//#region src/core/typed-from-entries.d.ts
+/**
+ * Creates an object from entries while preserving the key and value types from
+ * the input tuple array.
+ *
+ * This is a typed wrapper around `Object.fromEntries`.
+ *
+ * @example
+ * ```ts
+ * const status = typedFromEntries([
+ *   ["id", "1"],
+ *   ["active", true],
+ * ] as const);
+ *
+ * // inferred as: { id: "1"; active: true }
+ * ```
+ */
+declare function typedFromEntries<const T extends EntryTuples>(entries: T): ObjectFromEntries<T>;
+//#endregion
+//#region src/core/typed-keys.d.ts
+/**
+ * Returns the own enumerable string keys of an object with preserved key types.
+ *
+ * This is a typed wrapper around `Object.keys`.
+ *
+ * @example
+ * ```ts
+ * const user = { id: "1", name: "Umsizi" } as const;
+ *
+ * typedKeys(user); // ["id", "name"]
+ * ```
+ */
+declare function typedKeys<T extends object>(object: T): Array<StringKeyOf<T>>;
+//#endregion
+export { compactObject, filterValues, hasFileExtension, hasOwn, identity, isEmpty, isRenderFunction, mapValues, normalizePathname, omit, pick, typedEntries, typedFromEntries, typedKeys };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,6 +2,80 @@ import { t as normalizePathname } from "./next-C3wp7UoQ.js";
 import { t as hasFileExtension } from "./node-D-nlzpmG.js";
 import { t as isRenderFunction } from "./react-BCidSnzT.js";
 
+//#region src/core/typed-keys.ts
+/**
+* Returns the own enumerable string keys of an object with preserved key types.
+*
+* This is a typed wrapper around `Object.keys`.
+*
+* @example
+* ```ts
+* const user = { id: "1", name: "Umsizi" } as const;
+*
+* typedKeys(user); // ["id", "name"]
+* ```
+*/
+function typedKeys(object) {
+	return Object.keys(object);
+}
+
+//#endregion
+//#region src/core/compact-object.ts
+/**
+* Creates a new object with all `null` and `undefined` values removed.
+*
+* Other falsy values such as `0`, `false`, `""`, and `NaN` are preserved.
+*
+* @example
+* ```ts
+* const user = { id: "1", nickname: null, active: false } as const;
+*
+* compactObject(user); // { id: "1", active: false }
+* ```
+*/
+function compactObject(object) {
+	const result = {};
+	for (const key of typedKeys(object)) {
+		const value = object[key];
+		if (value != null) result[key] = value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/core/filter-values.ts
+function filterValues(object, predicate) {
+	const result = {};
+	for (const key of typedKeys(object)) {
+		const value = object[key];
+		if (predicate(value, key, object)) result[key] = value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/core/has-own.ts
+/**
+* Checks whether an object has the given property as its own key.
+*
+* This is a typed wrapper around `Object.hasOwn` that narrows the provided key
+* when the check succeeds.
+*
+* @example
+* ```ts
+* const user = { id: "1" };
+* const key: string = "id";
+*
+* if (hasOwn(user, key)) {
+*   user[key]; // key is narrowed to "id"
+* }
+* ```
+*/
+function hasOwn(object, key) {
+	return Object.hasOwn(object, key);
+}
+
+//#endregion
 //#region src/core/identity.ts
 /**
 * Returns the given value unchanged.
@@ -19,5 +93,105 @@ function identity(value) {
 }
 
 //#endregion
-export { hasFileExtension, identity, isRenderFunction, normalizePathname };
+//#region src/core/is-empty.ts
+/**
+* Returns `true` when an object has no own enumerable properties.
+*
+* Both string keys and symbol keys are considered. Non-enumerable properties
+* are ignored.
+*
+* @example
+* ```ts
+* isEmpty({}); // true
+* isEmpty({ id: "1" }); // false
+* ```
+*/
+function isEmpty(object) {
+	if (Object.keys(object).length > 0) return false;
+	for (const key of Object.getOwnPropertySymbols(object)) if (Object.prototype.propertyIsEnumerable.call(object, key)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/core/map-values.ts
+/**
+* Maps the values of an object's own enumerable string-keyed properties while
+* preserving the original enumerable string-key set.
+*
+* @example
+* ```ts
+* const counts = { draft: 1, published: 2 };
+*
+* mapValues(counts, (value) => value * 2);
+* // { draft: 2, published: 4 }
+* ```
+*/
+function mapValues(object, mapper) {
+	const result = {};
+	for (const key of typedKeys(object)) result[key] = mapper(object[key], key, object);
+	return result;
+}
+
+//#endregion
+//#region src/core/omit.ts
+function omit(object, firstKeyOrKeys, ...restKeys) {
+	const keys = Array.isArray(firstKeyOrKeys) ? firstKeyOrKeys : [firstKeyOrKeys, ...restKeys];
+	const omittedKeys = new Set(keys);
+	const result = {};
+	for (const key of Reflect.ownKeys(object)) if (Object.prototype.propertyIsEnumerable.call(object, key) && !omittedKeys.has(key)) result[key] = object[key];
+	return result;
+}
+
+//#endregion
+//#region src/core/pick.ts
+function pick(object, firstKeyOrKeys, ...restKeys) {
+	const keys = Array.isArray(firstKeyOrKeys) ? firstKeyOrKeys : [firstKeyOrKeys, ...restKeys];
+	const result = {};
+	for (const key of keys) if (hasOwn(object, key)) result[key] = object[key];
+	return result;
+}
+
+//#endregion
+//#region src/core/typed-entries.ts
+/**
+* Returns the own enumerable string-keyed entries of an object with preserved
+* key/value pairing.
+*
+* This is a typed wrapper around `Object.entries`.
+*
+* @example
+* ```ts
+* const user = { id: "1", active: true } as const;
+*
+* typedEntries(user); // [["id", "1"], ["active", true]]
+* ```
+*/
+function typedEntries(object) {
+	return Object.entries(object);
+}
+
+//#endregion
+//#region src/core/typed-from-entries.ts
+/**
+* Creates an object from entries while preserving the key and value types from
+* the input tuple array.
+*
+* This is a typed wrapper around `Object.fromEntries`.
+*
+* @example
+* ```ts
+* const status = typedFromEntries([
+*   ["id", "1"],
+*   ["active", true],
+* ] as const);
+*
+* // inferred as: { id: "1"; active: true }
+* ```
+*/
+function typedFromEntries(entries) {
+	return Object.fromEntries(entries);
+}
+
+//#endregion
+export { compactObject, filterValues, hasFileExtension, hasOwn, identity, isEmpty, isRenderFunction, mapValues, normalizePathname, omit, pick, typedEntries, typedFromEntries, typedKeys };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/core/identity.ts"],"sourcesContent":["/**\n * Returns the given value unchanged.\n *\n * Useful as a default callback, a type-inference anchor, or a no-op\n * placeholder where a transform function is expected.\n *\n * @example\n * ```ts\n * identity(\"umsizi\"); // \"umsizi\"\n * ```\n */\nexport function identity<T>(value: T): T {\n\treturn value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAWA,SAAgB,SAAY,OAAa;AACxC,QAAO"}
+{"version":3,"file":"index.js","names":["result: Partial<T>","result: Partial<T>"],"sources":["../src/core/typed-keys.ts","../src/core/compact-object.ts","../src/core/filter-values.ts","../src/core/has-own.ts","../src/core/identity.ts","../src/core/is-empty.ts","../src/core/map-values.ts","../src/core/omit.ts","../src/core/pick.ts","../src/core/typed-entries.ts","../src/core/typed-from-entries.ts"],"sourcesContent":["import type { StringKeyOf } from \"./types\";\n\n/**\n * Returns the own enumerable string keys of an object with preserved key types.\n *\n * This is a typed wrapper around `Object.keys`.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\" } as const;\n *\n * typedKeys(user); // [\"id\", \"name\"]\n * ```\n */\nexport function typedKeys<T extends object>(object: T): Array<StringKeyOf<T>> {\n\treturn Object.keys(object) as Array<StringKeyOf<T>>;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { CompactedObject } from \"./types\";\n\n/**\n * Creates a new object with all `null` and `undefined` values removed.\n *\n * Other falsy values such as `0`, `false`, `\"\"`, and `NaN` are preserved.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", nickname: null, active: false } as const;\n *\n * compactObject(user); // { id: \"1\", active: false }\n * ```\n */\nexport function compactObject<T extends object>(object: T): CompactedObject<T> {\n\tconst result = {} as CompactedObject<T>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (value != null) {\n\t\t\tresult[key] = value as Exclude<T[typeof key], null | undefined>;\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { FilteredValues, ValueGuard, ValuePredicate } from \"./types\";\n\n/**\n * Filters an object's own enumerable string-keyed properties by value.\n *\n * Supports both boolean predicates and type-guard predicates. The result type\n * remains partial because any property may be removed at runtime.\n *\n * @example\n * ```ts\n * const settings = { retries: 3, label: \"\", timeout: null } as const;\n *\n * filterValues(settings, (value) => value !== null);\n * // { retries: 3, label: \"\" }\n * ```\n */\nexport function filterValues<\n\tT extends object,\n\tS extends T[Extract<keyof T, string>],\n>(object: T, predicate: ValueGuard<T, S>): FilteredValues<T, S>;\nexport function filterValues<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): FilteredValues<T, T[Extract<keyof T, string>]>;\nexport function filterValues<T extends object>(\n\tobject: T,\n\tpredicate: ValuePredicate<T>,\n): FilteredValues<T, T[Extract<keyof T, string>]> {\n\tconst result = {} as FilteredValues<T, T[Extract<keyof T, string>]>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tconst value = object[key];\n\n\t\tif (predicate(value, key, object)) {\n\t\t\tresult[key] = value;\n\t\t}\n\t}\n\n\treturn result;\n}\n","/**\n * Checks whether an object has the given property as its own key.\n *\n * This is a typed wrapper around `Object.hasOwn` that narrows the provided key\n * when the check succeeds.\n *\n * @example\n * ```ts\n * const user = { id: \"1\" };\n * const key: string = \"id\";\n *\n * if (hasOwn(user, key)) {\n *   user[key]; // key is narrowed to \"id\"\n * }\n * ```\n */\nexport function hasOwn<T extends object, K extends PropertyKey>(\n\tobject: T,\n\tkey: K,\n): key is Extract<K, keyof T> {\n\treturn Object.hasOwn(object, key);\n}\n","/**\n * Returns the given value unchanged.\n *\n * Useful as a default callback, a type-inference anchor, or a no-op\n * placeholder where a transform function is expected.\n *\n * @example\n * ```ts\n * identity(\"umsizi\"); // \"umsizi\"\n * ```\n */\nexport function identity<T>(value: T): T {\n\treturn value;\n}\n","/**\n * Returns `true` when an object has no own enumerable properties.\n *\n * Both string keys and symbol keys are considered. Non-enumerable properties\n * are ignored.\n *\n * @example\n * ```ts\n * isEmpty({}); // true\n * isEmpty({ id: \"1\" }); // false\n * ```\n */\nexport function isEmpty(object: object): boolean {\n\tif (Object.keys(object).length > 0) {\n\t\treturn false;\n\t}\n\n\tfor (const key of Object.getOwnPropertySymbols(object)) {\n\t\tif (Object.prototype.propertyIsEnumerable.call(object, key)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n","import { typedKeys } from \"./typed-keys\";\nimport type { MappedValues, ValueMapper } from \"./types\";\n\n/**\n * Maps the values of an object's own enumerable string-keyed properties while\n * preserving the original enumerable string-key set.\n *\n * @example\n * ```ts\n * const counts = { draft: 1, published: 2 };\n *\n * mapValues(counts, (value) => value * 2);\n * // { draft: 2, published: 4 }\n * ```\n */\nexport function mapValues<T extends object, R>(\n\tobject: T,\n\tmapper: ValueMapper<T, R>,\n): MappedValues<T, R> {\n\tconst result = {} as MappedValues<T, R>;\n\n\tfor (const key of typedKeys(object)) {\n\t\tresult[key] = mapper(object[key], key, object);\n\t}\n\n\treturn result;\n}\n","/**\n * Creates a new object excluding the selected own enumerable properties.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\", role: \"admin\" } as const;\n *\n * omit(user, \"id\", \"name\"); // { role: \"admin\" }\n * omit(user, [\"role\"] as const); // { id: \"1\", name: \"Umsizi\" }\n * ```\n */\nexport function omit<T extends object, const Keys extends readonly (keyof T)[]>(\n\tobject: T,\n\t...keys: Keys\n): Omit<T, Keys[number]>;\nexport function omit<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tobject: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): Omit<T, FirstKey | RestKeys[number]>;\nexport function omit<T extends object>(\n\tobject: T,\n\tkeys: readonly (keyof T)[],\n): Partial<T>;\nexport function omit<T extends object>(\n\tobject: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): Partial<T> {\n\tconst keys = (\n\t\tArray.isArray(firstKeyOrKeys)\n\t\t\t? firstKeyOrKeys\n\t\t\t: [firstKeyOrKeys, ...restKeys]\n\t) as readonly (keyof T)[];\n\tconst omittedKeys = new Set<PropertyKey>(keys as readonly PropertyKey[]);\n\tconst result: Partial<T> = {};\n\n\tfor (const key of Reflect.ownKeys(object) as (keyof T)[]) {\n\t\tif (\n\t\t\tObject.prototype.propertyIsEnumerable.call(object, key) &&\n\t\t\t!omittedKeys.has(key)\n\t\t) {\n\t\t\t(result as T)[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import { hasOwn } from \"./has-own\";\n\n/**\n * Creates a new object containing only the selected own properties.\n *\n * Prefer the rest-key form for the strongest autocomplete and inference.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", name: \"Umsizi\", role: \"admin\" } as const;\n *\n * pick(user, \"name\"); // { name: \"Umsizi\" }\n * pick(user, [\"id\", \"role\"] as const); // { id: \"1\", role: \"admin\" }\n * ```\n */\nexport function pick<T extends object, const Keys extends readonly (keyof T)[]>(\n\tobject: T,\n\t...keys: Keys\n): Pick<T, Keys[number]>;\nexport function pick<\n\tT extends object,\n\tconst FirstKey extends keyof T,\n\tconst RestKeys extends readonly (keyof T)[],\n>(\n\tobject: T,\n\tkeys: readonly [FirstKey, ...RestKeys],\n): Pick<T, FirstKey | RestKeys[number]>;\nexport function pick<T extends object>(\n\tobject: T,\n\tkeys: readonly (keyof T)[],\n): Partial<T>;\nexport function pick<T extends object>(\n\tobject: T,\n\tfirstKeyOrKeys: keyof T | readonly (keyof T)[],\n\t...restKeys: readonly (keyof T)[]\n): Partial<T> {\n\tconst keys = (\n\t\tArray.isArray(firstKeyOrKeys)\n\t\t\t? firstKeyOrKeys\n\t\t\t: [firstKeyOrKeys, ...restKeys]\n\t) as readonly (keyof T)[];\n\tconst result: Partial<T> = {};\n\n\tfor (const key of keys) {\n\t\tif (hasOwn(object, key)) {\n\t\t\tresult[key] = object[key];\n\t\t}\n\t}\n\n\treturn result;\n}\n","import type { ObjectEntries } from \"./types\";\n\n/**\n * Returns the own enumerable string-keyed entries of an object with preserved\n * key/value pairing.\n *\n * This is a typed wrapper around `Object.entries`.\n *\n * @example\n * ```ts\n * const user = { id: \"1\", active: true } as const;\n *\n * typedEntries(user); // [[\"id\", \"1\"], [\"active\", true]]\n * ```\n */\nexport function typedEntries<T extends object>(object: T): ObjectEntries<T> {\n\treturn Object.entries(object) as unknown as ObjectEntries<T>;\n}\n","import type { EntryTuples, ObjectFromEntries } from \"./types\";\n\n/**\n * Creates an object from entries while preserving the key and value types from\n * the input tuple array.\n *\n * This is a typed wrapper around `Object.fromEntries`.\n *\n * @example\n * ```ts\n * const status = typedFromEntries([\n *   [\"id\", \"1\"],\n *   [\"active\", true],\n * ] as const);\n *\n * // inferred as: { id: \"1\"; active: true }\n * ```\n */\nexport function typedFromEntries<const T extends EntryTuples>(\n\tentries: T,\n): ObjectFromEntries<T> {\n\treturn Object.fromEntries(entries) as ObjectFromEntries<T>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAcA,SAAgB,UAA4B,QAAkC;AAC7E,QAAO,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;ACA3B,SAAgB,cAAgC,QAA+B;CAC9E,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,OAAO,UAAU,OAAO,EAAE;EACpC,MAAM,QAAQ,OAAO;AAErB,MAAI,SAAS,KACZ,QAAO,OAAO;;AAIhB,QAAO;;;;;ACDR,SAAgB,aACf,QACA,WACiD;CACjD,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,OAAO,UAAU,OAAO,EAAE;EACpC,MAAM,QAAQ,OAAO;AAErB,MAAI,UAAU,OAAO,KAAK,OAAO,CAChC,QAAO,OAAO;;AAIhB,QAAO;;;;;;;;;;;;;;;;;;;;;ACvBR,SAAgB,OACf,QACA,KAC6B;AAC7B,QAAO,OAAO,OAAO,QAAQ,IAAI;;;;;;;;;;;;;;;;ACTlC,SAAgB,SAAY,OAAa;AACxC,QAAO;;;;;;;;;;;;;;;;;ACAR,SAAgB,QAAQ,QAAyB;AAChD,KAAI,OAAO,KAAK,OAAO,CAAC,SAAS,EAChC,QAAO;AAGR,MAAK,MAAM,OAAO,OAAO,sBAAsB,OAAO,CACrD,KAAI,OAAO,UAAU,qBAAqB,KAAK,QAAQ,IAAI,CAC1D,QAAO;AAIT,QAAO;;;;;;;;;;;;;;;;;ACRR,SAAgB,UACf,QACA,QACqB;CACrB,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,OAAO,UAAU,OAAO,CAClC,QAAO,OAAO,OAAO,OAAO,MAAM,KAAK,OAAO;AAG/C,QAAO;;;;;ACIR,SAAgB,KACf,QACA,gBACA,GAAG,UACU;CACb,MAAM,OACL,MAAM,QAAQ,eAAe,GAC1B,iBACA,CAAC,gBAAgB,GAAG,SAAS;CAEjC,MAAM,cAAc,IAAI,IAAiB,KAA+B;CACxE,MAAMA,SAAqB,EAAE;AAE7B,MAAK,MAAM,OAAO,QAAQ,QAAQ,OAAO,CACxC,KACC,OAAO,UAAU,qBAAqB,KAAK,QAAQ,IAAI,IACvD,CAAC,YAAY,IAAI,IAAI,CAErB,CAAC,OAAa,OAAO,OAAO;AAI9B,QAAO;;;;;ACpBR,SAAgB,KACf,QACA,gBACA,GAAG,UACU;CACb,MAAM,OACL,MAAM,QAAQ,eAAe,GAC1B,iBACA,CAAC,gBAAgB,GAAG,SAAS;CAEjC,MAAMC,SAAqB,EAAE;AAE7B,MAAK,MAAM,OAAO,KACjB,KAAI,OAAO,QAAQ,IAAI,CACtB,QAAO,OAAO,OAAO;AAIvB,QAAO;;;;;;;;;;;;;;;;;;AClCR,SAAgB,aAA+B,QAA6B;AAC3E,QAAO,OAAO,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;ACE9B,SAAgB,iBACf,SACuB;AACvB,QAAO,OAAO,YAAY,QAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umsizi",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A zero-dependency TypeScript utility library.",
   "license": "MIT",
   "author": "Jack-WebDev",
@@ -92,7 +92,7 @@
   ],
   "scripts": {
     "build": "tsdown",
-    "ci": "pnpm run lint && pnpm run check-types && pnpm run test:coverage && pnpm run build && pnpm exec size-limit && pnpm run check:package",
+    "ci": "pnpm run lint && pnpm run check-types && pnpm run check-types:examples && pnpm run test:coverage && pnpm run build && pnpm exec size-limit && pnpm run check:package",
     "check:package": "pnpm run check:package:npm && pnpm run check:package:jsr",
     "check:package:jsr": "pnpm dlx jsr publish --dry-run --allow-dirty",
     "check:package:npm": "HUSKY=0 npm_config_cache=/tmp/umsizi-npm-cache npm pack --dry-run --ignore-scripts",
@@ -101,6 +101,7 @@
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "check-types": "tsc --noEmit",
+    "check-types:examples": "tsc --noEmit --project tsconfig.json --pretty false",
     "release:publish": "pnpm run build && pnpm exec changeset publish && pnpm dlx jsr publish --allow-dirty",
     "release:version": "pnpm exec changeset version && node ./scripts/sync-release-version.mjs",
     "test": "vitest run",