@luxass/utils 2.3.0 → 2.4.0

package/dist/{guards-C19fJmlu.d.ts → guards-x9QZDUSt.d.ts}

@@ -55,6 +55,5 @@ declare function isNotUndefined<T>(v: T): v is Exclude<T, undefined>;
  * ```
  */
 declare function isTruthy<T>(v: T): v is NonNullable<T>;
-
 //#endregion
-export { isNotNull as isNotNull$1, isNotNullish as isNotNullish$1, isNotUndefined as isNotUndefined$1, isTruthy as isTruthy$1 };
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/guards.d.ts

@@ -1,2 +1,2 @@
-import { isNotNull$1 as isNotNull, isNotNullish$1 as isNotNullish, isNotUndefined$1 as isNotUndefined, isTruthy$1 as isTruthy } from "./guards-C19fJmlu.js";
+import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-x9QZDUSt.js";
 export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { isNotNull$1 as isNotNull, isNotNullish$1 as isNotNullish, isNotUndefined$1 as isNotUndefined, isTruthy$1 as isTruthy } from "./guards-C19fJmlu.js";
-import { clamp$1 as clamp } from "./number-C2E_sOOy.js";
-import { capitalize$1 as capitalize, dedent$1 as dedent, dedentRaw$1 as dedentRaw, formatStr$1 as formatStr, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string-CBWIJiC0.js";
-import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-QETho94V.js";
+import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-x9QZDUSt.js";
+import { clamp } from "./number-DzUC7V5F.js";
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BT3S70pM.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BjsgnDeW.js";
+import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-DCrM3M9i.js";
 import pRetry from "p-retry";
 
 //#region src/common.d.ts
@@ -19,6 +20,5 @@ declare class InvariantError extends Error {
  * @throws {InvariantError} Throws when the predicate is falsy
  */
 declare function invariant(predicate: unknown, message: string, ...positionals: unknown[]): asserts predicate;
-
 //#endregion
-export { ElementOf, InferArguments, InvariantError, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+export { ElementOf, InferArguments, InvariantError, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, capitalize, clamp, dedent, dedentRaw, formatStr, getChangedKeys, getOwnProperty, hasOwnProperty, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, omit, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/index.js

@@ -1,6 +1,7 @@
 import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-O1HGJraI.js";
 import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-pQApOGKP.js";
 import { clamp } from "./number-BS9T5WGO.js";
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-CyGLe77G.js";
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -82,10 +83,10 @@ var require_retry_operation = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node
 	RetryOperation$1.prototype.retry = function(err) {
 		if (this._timeout) clearTimeout(this._timeout);
 		if (!err) return false;
-		var currentTime = new Date().getTime();
+		var currentTime = (/* @__PURE__ */ new Date()).getTime();
 		if (err && currentTime - this._operationStart >= this._maxRetryTime) {
 			this._errors.push(err);
-			this._errors.unshift(new Error("RetryOperation timeout occurred"));
+			this._errors.unshift(/* @__PURE__ */ new Error("RetryOperation timeout occurred"));
 			return false;
 		}
 		this._errors.push(err);
@@ -118,7 +119,7 @@ var require_retry_operation = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node
 		if (this._operationTimeoutCb) this._timeout = setTimeout(function() {
 			self._operationTimeoutCb();
 		}, self._operationTimeout);
-		this._operationStart = new Date().getTime();
+		this._operationStart = (/* @__PURE__ */ new Date()).getTime();
 		this._fn(this._attempts);
 	};
 	RetryOperation$1.prototype.try = function(fn) {
@@ -278,7 +279,7 @@ async function pRetry(input, options) {
 		options.onFailedAttempt ??= () => {};
 		options.shouldRetry ??= () => true;
 		options.retries ??= 10;
-		const operation = import_retry.default.operation(options);
+		const operation = import_retry.operation(options);
 		const abortHandler = () => {
 			operation.stop();
 			reject(options.signal?.reason);
@@ -316,4 +317,4 @@ async function pRetry(input, options) {
 }
 
 //#endregion
-export { InvariantError, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+export { InvariantError, capitalize, clamp, dedent, dedentRaw, formatStr, getChangedKeys, getOwnProperty, hasOwnProperty, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, omit, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/{number-C2E_sOOy.d.ts → number-DzUC7V5F.d.ts}

@@ -19,6 +19,5 @@
  * ```
  */
 declare function clamp(value: number, min: number, max: number): number;
-
 //#endregion
-export { clamp as clamp$1 };
+export { clamp };

package/dist/number.d.ts

@@ -1,2 +1,2 @@
-import { clamp$1 as clamp } from "./number-C2E_sOOy.js";
+import { clamp } from "./number-DzUC7V5F.js";
 export { clamp };

package/dist/object-BT3S70pM.d.ts

@@ -0,0 +1,84 @@
+//#region src/object.d.ts
+/**
+ * Checks if an object has a specific property as its own property (not inherited).
+ *
+ * @param {object} obj - The object to check
+ * @param {string} key - The property key to check for
+ * @returns {boolean} `true` if the object has the property as its own property, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { hasOwnProperty } from '@luxass/utils/object';
+ *
+ * const obj = { name: 'John' };
+ * hasOwnProperty(obj, 'name'); // true
+ * hasOwnProperty(obj, 'toString'); // false (inherited)
+ * ```
+ */
+declare function hasOwnProperty(obj: object, key: string): boolean;
+/**
+ * Safely gets an own property value from an object, returning undefined if the property doesn't exist.
+ *
+ * This function provides type-safe property access with multiple overloads:
+ * - For objects with known key-value types, returns the value type or undefined
+ * - For generic objects, returns the property value type or undefined
+ * - Fallback returns unknown type
+ *
+ * @param {object} obj - The object to get the property from
+ * @param {string} key - The property key to retrieve
+ * @returns {unknown} The property value if it exists as an own property, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * import { getOwnProperty } from '@luxass/utils/object';
+ *
+ * const obj = { name: 'John', age: 30 };
+ * getOwnProperty(obj, 'name'); // 'John'
+ * getOwnProperty(obj, 'missing'); // undefined
+ * ```
+ */
+declare function getOwnProperty<K extends string, V>(obj: Partial<Record<K, V>>, key: K): V | undefined;
+declare function getOwnProperty<O extends object>(obj: O, key: string): O[keyof O] | undefined;
+declare function getOwnProperty(obj: object, key: string): unknown;
+/**
+ * Compares two objects and returns an array of keys where the values differ.
+ *
+ * Uses Object.is() for comparison, which handles special cases like NaN and -0/+0 correctly.
+ * Only checks keys that exist in the first object.
+ *
+ * @template T - The type of objects being compared
+ * @param {T} obj1 - The first object to compare
+ * @param {T} obj2 - The second object to compare
+ * @returns {(keyof T)[]} An array of keys where the values differ between the two objects
+ *
+ * @example
+ * ```typescript
+ * import { getChangedKeys } from '@luxass/utils/object';
+ *
+ * const obj1 = { name: 'John', age: 30, city: 'NYC' };
+ * const obj2 = { name: 'John', age: 31, city: 'NYC' };
+ * getChangedKeys(obj1, obj2); // ['age']
+ * ```
+ */
+declare function getChangedKeys<T extends object>(obj1: T, obj2: T): (keyof T)[];
+/**
+ * Creates a new object with specified keys omitted from the original object.
+ *
+ * This function creates a shallow copy of the input object and removes the specified keys.
+ * The original object is not modified.
+ *
+ * @param {Record<string, unknown>} obj - The source object to omit keys from
+ * @param {ReadonlyArray<string>} keys - An array of key names to omit from the object
+ * @returns {Record<string, unknown>} A new object with the specified keys removed
+ *
+ * @example
+ * ```typescript
+ * import { omit } from '@luxass/utils/object';
+ *
+ * const obj = { name: 'John', age: 30, city: 'NYC', country: 'USA' };
+ * omit(obj, ['age', 'country']); // { name: 'John', city: 'NYC' }
+ * ```
+ */
+declare function omit(obj: Record<string, unknown>, keys: ReadonlyArray<string>): Record<string, unknown>;
+//#endregion
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/object-CyGLe77G.js

@@ -0,0 +1,75 @@
+//#region src/object.ts
+/**
+* Checks if an object has a specific property as its own property (not inherited).
+*
+* @param {object} obj - The object to check
+* @param {string} key - The property key to check for
+* @returns {boolean} `true` if the object has the property as its own property, `false` otherwise
+*
+* @example
+* ```typescript
+* import { hasOwnProperty } from '@luxass/utils/object';
+*
+* const obj = { name: 'John' };
+* hasOwnProperty(obj, 'name'); // true
+* hasOwnProperty(obj, 'toString'); // false (inherited)
+* ```
+*/
+function hasOwnProperty(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function getOwnProperty(obj, key) {
+	if (!hasOwnProperty(obj, key)) return void 0;
+	return obj[key];
+}
+/**
+* Compares two objects and returns an array of keys where the values differ.
+*
+* Uses Object.is() for comparison, which handles special cases like NaN and -0/+0 correctly.
+* Only checks keys that exist in the first object.
+*
+* @template T - The type of objects being compared
+* @param {T} obj1 - The first object to compare
+* @param {T} obj2 - The second object to compare
+* @returns {(keyof T)[]} An array of keys where the values differ between the two objects
+*
+* @example
+* ```typescript
+* import { getChangedKeys } from '@luxass/utils/object';
+*
+* const obj1 = { name: 'John', age: 30, city: 'NYC' };
+* const obj2 = { name: 'John', age: 31, city: 'NYC' };
+* getChangedKeys(obj1, obj2); // ['age']
+* ```
+*/
+function getChangedKeys(obj1, obj2) {
+	const result = [];
+	for (const key in obj1) if (!Object.is(obj1[key], obj2[key])) result.push(key);
+	return result;
+}
+/**
+* Creates a new object with specified keys omitted from the original object.
+*
+* This function creates a shallow copy of the input object and removes the specified keys.
+* The original object is not modified.
+*
+* @param {Record<string, unknown>} obj - The source object to omit keys from
+* @param {ReadonlyArray<string>} keys - An array of key names to omit from the object
+* @returns {Record<string, unknown>} A new object with the specified keys removed
+*
+* @example
+* ```typescript
+* import { omit } from '@luxass/utils/object';
+*
+* const obj = { name: 'John', age: 30, city: 'NYC', country: 'USA' };
+* omit(obj, ['age', 'country']); // { name: 'John', city: 'NYC' }
+* ```
+*/
+function omit(obj, keys) {
+	const result = { ...obj };
+	for (const key of keys) delete result[key];
+	return result;
+}
+
+//#endregion
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/object.d.ts

@@ -0,0 +1,2 @@
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BT3S70pM.js";
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/object.js

@@ -0,0 +1,3 @@
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-CyGLe77G.js";
+
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/{string-CBWIJiC0.d.ts → string-BjsgnDeW.d.ts}

@@ -129,4 +129,4 @@ declare function sanitizeIdentifier(str: string): string;
  */
 declare function formatStr(message: string, ...positionals: unknown[]): string;
 //#endregion
-export { capitalize as capitalize$1, dedent as dedent$1, dedentRaw as dedentRaw$1, formatStr as formatStr$1, sanitizeIdentifier as sanitizeIdentifier$1, toCamelCase as toCamelCase$1, toKebabCase as toKebabCase$1, toPascalCase as toPascalCase$1, toSnakeCase as toSnakeCase$1 };
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.d.ts

@@ -1,2 +1,2 @@
-import { capitalize$1 as capitalize, dedent$1 as dedent, dedentRaw$1 as dedentRaw, formatStr$1 as formatStr, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string-CBWIJiC0.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BjsgnDeW.js";
 export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/{types-QETho94V.d.ts → types-DCrM3M9i.d.ts}

@@ -82,6 +82,5 @@ type Prettify<T> = { [K in keyof T]: T[K] } & {};
  * ```
  */
 type RemoveIndexSignature<T> = { [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K] };
-
 //#endregion
 export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature };

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-QETho94V.js";
+import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-DCrM3M9i.js";
 export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxass/utils",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -23,9 +23,10 @@
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.js",
-    "./string": "./dist/string.js",
     "./guards": "./dist/guards.js",
     "./number": "./dist/number.js",
+    "./object": "./dist/object.js",
+    "./string": "./dist/string.js",
     "./types": "./dist/types.js",
     "./package.json": "./package.json"
   },
@@ -48,7 +49,7 @@
     "eslint": "^9.27.0",
     "eslint-plugin-format": "^1.0.1",
     "publint": "^0.3.12",
-    "tsdown": "^0.11.12",
+    "tsdown": "^0.12.9",
     "typescript": "^5.8.3",
     "vitest": "^3.1.4",
     "vitest-package-exports": "^0.1.1"