@hichchi/utils 0.0.1-beta.2 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hichchi/utils",
-  "version": "0.0.1-beta.2",
+  "version": "0.0.2",
   "publishConfig": {
     "access": "public"
   },
@@ -11,12 +11,17 @@
   "keywords": [],
   "author": "Waruna Udayanga",
   "license": "MIT",
-  "main": "./index.js",
-  "typings": "./index.d.ts",
   "sideEffects": false,
-  "dependencies": {
-    "tslib": "^2.3.0"
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
   },
-  "types": "./index.d.ts",
-  "type": "commonjs"
-}
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
+}

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./utils";
+export * from "./interfaces";
+export * from "./types";
+export * from "./enums";
+export * from "./constants";

package/{interfaces → src/interfaces}/infinite-object.interface.d.ts

@@ -18,9 +18,9 @@
  * This type is often used in conjunction with utility functions for traversing, flattening,
  * or manipulating deeply nested object structures.
  *
- * @see PathValueSet A flattened representation of nested objects
- * @see {@link objectToPathValueSet} Utility to convert nested objects to PathValueSet
- * @see {@link pathValueSetToObject} Utility to convert PathValueSet back to nested objects
+ * @see DottedPathValueObject A flattened representation of nested objects
+ * @see {@link objectToDottedPathValueObject} Utility to convert nested objects to DottedPathValueObject
+ * @see {@link dottedPathObjectToNested} Utility to convert DottedPathValueObject back to nested objects
  *
  * @example
  * ```typescript

package/{interfaces → src/interfaces}/path-value-set.interface.d.ts

@@ -6,12 +6,12 @@
  * - Keys are string paths using dot notation to represent the original object hierarchy
  * - Values are limited to primitive types (string, number, boolean)
  *
- * PathValueSet provides a serialization-friendly format for complex nested objects, making them
+ * DottedPathValueObject provides a serialization-friendly format for complex nested objects, making them
  * easier to store, transmit, or manipulate in certain contexts (like databases, query params,
  * or form handling).
  *
  * @remarks
- * The PathValueSet format offers several benefits:
+ * The DottedPathValueObject format offers several benefits:
  *
  * - **Simplicity**: Eliminates nested structure complexity, making it easier to iterate over all properties
  * - **Queryability**: Enables direct access to deeply nested values without traversal logic
@@ -25,13 +25,13 @@
  * - Creating update operations that target specific nested properties
  *
  * @see {@link InfiniteObject} The complementary nested object representation
- * @see {@link objectToPathValueSet} Utility to convert nested objects to PathValueSet
- * @see {@link pathValueSetToObject} Utility to convert PathValueSet back to nested objects
+ * @see {@link objectToDottedPathValueObject} Utility to convert nested objects to DottedPathValueObject
+ * @see {@link dottedPathObjectToNested} Utility to convert DottedPathValueObject back to nested objects
  *
  * @example
  * ```typescript
- * // A PathValueSet representing a nested user object
- * const userPathValues: PathValueSet = {
+ * // A DottedPathValueObject representing a nested user object
+ * const userPathValues: DottedPathValueObject = {
  *   'id': 123,
  *   'name': 'John Doe',
  *   'isActive': true,
@@ -43,8 +43,8 @@
  *
  * @example
  * ```typescript
- * // Converting between nested objects and PathValueSet
- * import { objectToPathValueSet, pathValueSetToObject } from './object.utils';
+ * // Converting between nested objects and DottedPathValueObject
+ * import { objectToDottedPathValueObject, dottedPathObjectToNested } from './object.utils';
  *
  * const user = {
  *   id: 123,
@@ -58,11 +58,11 @@
  *   }
  * };
  *
- * // Convert to PathValueSet
- * const pathValues = objectToPathValueSet(user);
+ * // Convert to DottedPathValueObject
+ * const pathValues = objectToDottedPathValueObject(user);
  *
  * // Convert back to nested object
- * const reconstructedUser = pathValueSetToObject(pathValues);
+ * const reconstructedUser = dottedPathObjectToNested(pathValues);
  * ```
  *
  * @example
@@ -74,6 +74,6 @@
  * userPathValues['profile.address.city'] = 'Boston';
  * ```
  */
-export interface PathValueSet {
+export interface DottedPathValueObject {
     [path: string]: string | number | boolean;
 }

package/{types → src/types}/deep-partial.type.d.ts

@@ -45,3 +45,9 @@
 export type DeepPartial<T> = T | (T extends Array<infer U> ? DeepPartial<U>[] : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer M> ? Set<DeepPartial<M>> : T extends object ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : T);
+/**
+ * Lightweight recursive partial type for plain object filtering/comparison use-cases.
+ */
+export type SimpleDeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? SimpleDeepPartial<T[K]> : T[K];
+};

package/{types → src/types}/literal-object.type.d.ts

@@ -41,8 +41,8 @@
  * }
  * ```
  *
- * @see {@link objectToPathValueSet} Utility that uses LiteralObject for object flattening
- * @see {@link PathValueSet} Related interface for flattened object representation
+ * @see {@link objectToDottedPathValueObject} Utility that uses LiteralObject for object flattening
+ * @see {@link DottedPathValueObject} Related interface for flattened object representation
  */
 export interface LiteralObject<T = any> {
     [key: string]: T;

package/{utils → src/utils}/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./url.utils";
+export * from "./file.utils";
 export * from "./object.utils";
 export * from "./string.utils";
 export * from "./assertions.utils";

package/{utils → src/utils}/object.utils.d.ts

@@ -1,5 +1,5 @@
-import { InfiniteObject, PathValueSet } from "../interfaces";
-import { LiteralObject, PartialWithNull } from "../types";
+import { InfiniteObject, DottedPathValueObject } from "../interfaces";
+import { LiteralObject, PartialWithNull, SimpleDeepPartial } from "../types";
 /**
  * Deep copy an object.
  * @template T Type of the object.
@@ -210,7 +210,7 @@ export declare const getMapKeys: (map: Map<string, string>, partialValue: string
  * - Works with any type of grouping key (string, number, boolean, objects, etc.)
  * - Empty arrays will return an empty Map
  */
-export declare const groupBy: <K, V>(list: Array<V>, keyGetter: (input: V) => K) => Map<K | null, Array<V>>;
+export declare const groupBy: <K, V>(list: Array<V>, keyGetter: (input: V) => K) => Map<K, Array<V>>;
 /**
  * Retrieves all values from a Map that contain a specified substring.
  *
@@ -332,7 +332,7 @@ export declare const searchMapValues: (map: Map<string, string>, partialValue: s
  */
 export declare const getValueByPath: <T>(obj: InfiniteObject, path: string) => T | undefined;
 /**
- * Converts a nested object into a flattened PathValueSet representation.
+ * Converts a nested object into a flattened DottedPathValueObject representation.
  *
  * This function transforms a hierarchical object structure into a flat key-value map
  * where keys represent paths to values in the original object using dot notation.
@@ -342,7 +342,7 @@ export declare const getValueByPath: <T>(obj: InfiniteObject, path: string) => T
  * path-based entries like `{ 'user.name': 'John' }`.
  *
  * @param {LiteralObject} obj - The nested object to flatten
- * @returns {PathValueSet} - A flattened representation where:
+ * @returns {DottedPathValueObject} - A flattened representation where:
  *   - Keys are dot-notation paths to values in the original object
  *   - Values are primitive values (strings, numbers, booleans) from the original object
  *
@@ -351,8 +351,8 @@ export declare const getValueByPath: <T>(obj: InfiniteObject, path: string) => T
  * - Only primitive values (string, number, boolean) are supported as leaf values
  * - Circular references are not handled and will cause a stack overflow
  *
- * @see {@link pathValueSetToObject} The inverse operation to convert a PathValueSet back to a nested object
- * @see {@link PathValueSet} The interface for the returned flattened object
+ * @see {@link dottedPathObjectToNested} The inverse operation to convert a DottedPathValueObject back to a nested object
+ * @see {@link DottedPathValueObject} The interface for the returned flattened object
  *
  * @example
  * ```typescript
@@ -370,7 +370,7 @@ export declare const getValueByPath: <T>(obj: InfiniteObject, path: string) => T
  *   }
  * };
  *
- * const flattened = objectToPathValueSet(user);
+ * const flattened = objectToDottedPathValueObject(user);
  *
  * // Result:
  * // {
@@ -383,19 +383,19 @@ export declare const getValueByPath: <T>(obj: InfiniteObject, path: string) => T
  * // }
  * ```
  */
-export declare function objectToPathValueSet(obj: LiteralObject): PathValueSet;
+export declare function objectToDottedPathValueObject(obj: LiteralObject): DottedPathValueObject;
 /**
- * Converts a flattened PathValueSet back into a nested object structure.
+ * Converts a flattened DottedPathValueObject back into a nested object structure.
  *
- * This function is the inverse of `objectToPathValueSet`. It takes a flat map of
+ * This function is the inverse of `objectToDottedPathValueObject`. It takes a flat map of
  * dot-notation paths to values and reconstructs a hierarchical object structure.
  *
- * Each key in the input PathValueSet represents a path through the object hierarchy,
+ * Each key in the input DottedPathValueObject represents a path through the object hierarchy,
  * with dots separating each level. The function builds a nested object structure by
  * parsing these paths and placing values at the appropriate locations.
  *
  * @template R - The type of the returned object (defaults to object)
- * @param {PathValueSet} pathValueSet - A flattened object with dot-notation path keys
+ * @param {DottedPathValueObject} pathValueSet - A flattened object with dot-notation path keys
  * @returns {R} - A reconstructed nested object with the original hierarchy
  *
  * @remarks
@@ -403,12 +403,12 @@ export declare function objectToPathValueSet(obj: LiteralObject): PathValueSet;
  * - Invalid paths are silently skipped (not included in the result)
  * - Path components should contain only alphanumeric characters, underscores, hyphens, and dots
  *
- * @see {@link objectToPathValueSet} The inverse operation to convert an object to PathValueSet
- * @see {@link PathValueSet} The interface for the input flattened object
+ * @see {@link objectToDottedPathValueObject} The inverse operation to convert an object to DottedPathValueObject
+ * @see {@link DottedPathValueObject} The interface for the input flattened object
  *
  * @example
  * ```typescript
- * // Convert a flat PathValueSet to a nested object
+ * // Convert a flat DottedPathValueObject to a nested object
  * const flatData = {
  *   "id": 123,
  *   "name": "John Doe",
@@ -417,7 +417,7 @@ export declare function objectToPathValueSet(obj: LiteralObject): PathValueSet;
  *   "profile.address.zip": "10001"
  * };
  *
- * const nestedObject = pathValueSetToObject(flatData);
+ * const nestedObject = dottedPathObjectToNested(flatData);
  *
  * Result:
  * // {
@@ -448,11 +448,11 @@ export declare function objectToPathValueSet(obj: LiteralObject): PathValueSet;
  *   };
  * }
  *
- * const userData = pathValueSetToObject<User>(flatData);
+ * const userData = dottedPathObjectToNested<User>(flatData);
  * // Returns object with User type
  * ```
  */
-export declare function pathValueSetToObject<R = object>(pathValueSet: Record<string, any>): R;
+export declare function dottedPathObjectToNested<R = object>(pathValueSet: Record<string, any>): R;
 /**
  * Creates a new object by omitting specified properties and undefined values from the original object.
  *
@@ -910,3 +910,7 @@ export declare function hasOwnAll(obj: Record<PropertyKey, unknown>, props: Prop
  * @see {@link Object.values} The underlying method used to extract enum entries
  */
 export declare function getEnumValues<T extends object>(e: T): T[keyof T][];
+/**
+ * Filters items by recursively matching nested property values.
+ */
+export declare function filterByObject<T>(items: T[], filters: SimpleDeepPartial<T>): T[];

package/CHANGELOG.md

@@ -1,19 +0,0 @@
-## 0.0.1-beta.2 (2025-07-18)
-
-This was a version bump only for utils to align it with other projects, there were no code changes.
-
-## 0.0.1-beta.1 (2025-07-16)
-
-This was a version bump only for utils to align it with other projects, there were no code changes.
-
-## 0.0.1-beta.0 (2025-07-15)
-
-This was a version bump only for utils to align it with other projects, there were no code changes.
-
-## 0.0.1-alpha.1 (2025-06-23)
-
-This was a version bump only for utils to align it with other projects, there were no code changes.
-
-## 0.0.1-alpha.0 (2025-06-23)
-
-This was a version bump only for utils to align it with other projects, there were no code changes.