@hichchi/utils 0.0.1-alpha.1 → 0.0.1-beta.1

package/interfaces/inflection-rule.interfaces.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Rule type for word inflection transformation
+ *
+ * This interface defines the structure of a single inflection rule, which consists of:
+ * - A regular expression pattern to match words that the rule applies to
+ * - A replacement string or function to transform the matched word
+ *
+ * The replacement can be either a static string with capture group references
+ * (e.g., "$1s") or a function that takes the matched string and returns the
+ * transformed version.
+ *
+ * @example
+ * ```typescript
+ * // Simple string replacement rule (add 's' to the end)
+ * const pluralRule: InflectionRule = {
+ *   regex: /(.*)$/i,
+ *   replacement: "$1s"
+ * };
+ *
+ * // Function-based replacement rule
+ * const singularRule: InflectionRule = {
+ *   regex: /(buses|dishes|matches)$/i,
+ *   replacement: (match: string): string => match.slice(0, -2)
+ * };
+ * ```
+ *
+ * @see {@link PluralSingularRulePair} Interface that uses InflectionRule for rule pairs
+ * @see {@link EnglishInflectionRules} Constant that implements these rules
+ */
+export interface InflectionRule {
+    /**
+     * Regular expression pattern to match words this rule applies to
+     */
+    regex: RegExp;
+    /**
+     * Replacement string with capture group references or function to transform the matched word
+     */
+    replacement: string | ((match: string) => string);
+}
+/**
+ * Pair of rule sets for bidirectional singular/plural transformations
+ *
+ * This interface defines a pair of rule sets for transforming words between
+ * singular and plural forms:
+ * - toPlural: Rules for converting singular words to plural form
+ * - toSingular: Rules for converting plural words to singular form
+ *
+ * Each rule set is an array of InflectionRule objects that are applied in order
+ * until a matching rule is found.
+ *
+ * @example
+ * ```typescript
+ * // Rule pair for words ending in -y
+ * const yRules: PluralSingularRulePair = {
+ *   toPlural: [
+ *     { regex: /([^aeiou])y$/i, replacement: "$1ies" }, // city -> cities
+ *     { regex: /([aeiou]y)$/i, replacement: "$1s" }     // boy -> boys
+ *   ],
+ *   toSingular: [
+ *     { regex: /([^aeiou])ies$/i, replacement: "$1y" }  // cities -> city
+ *   ]
+ * };
+ * ```
+ *
+ * @see {@link InflectionRule} Interface for individual transformation rules
+ * @see {@link InflectionRuleCategories} Interface that uses PluralSingularRulePair for categories
+ */
+export interface PluralSingularRulePair {
+    /**
+     * Array of rules for converting singular words to plural form
+     */
+    toPlural: InflectionRule[];
+    /**
+     * Array of rules for converting plural words to singular form
+     */
+    toSingular: InflectionRule[];
+}
+/**
+ * Categories of English inflection rules
+ *
+ * This interface defines the structure for organizing English inflection rules
+ * into linguistic categories. Each category represents a different type of
+ * inflection pattern in English:
+ *
+ * - INVARIANT: Words that are the same in singular and plural form (e.g., "fish", "sheep")
+ * - IRREGULAR: Words with irregular plural forms (e.g., "child/children", "man/men")
+ * - LATIN_GREEK: Words borrowed from Latin and Greek (e.g., "cactus/cacti", "analysis/analyses")
+ * - PATTERN_RULES: Words with specific ending patterns (e.g., words ending in -y, -f, -o)
+ * - DEFAULT: Default rules for standard transformations (adding/removing 's')
+ *
+ * Rules are typically applied in the order listed above, from most specific to most general.
+ *
+ * @example
+ * ```typescript
+ * // Using the categories in a word inflection function
+ * function plural(word: string): string {
+ *   // Combine all rules in priority order
+ *   const rules: InflectionRule[] = [
+ *     ...EnglishInflectionRules.INVARIANT,
+ *     ...EnglishInflectionRules.IRREGULAR.toPlural,
+ *     ...EnglishInflectionRules.LATIN_GREEK.toPlural,
+ *     ...EnglishInflectionRules.PATTERN_RULES.toPlural,
+ *     ...EnglishInflectionRules.DEFAULT.toPlural,
+ *   ];
+ *
+ *   // Apply the first matching rule
+ *   for (const rule of rules) {
+ *     if (rule.regex.test(word)) {
+ *       return word.replace(rule.regex, rule.replacement as string);
+ *     }
+ *   }
+ *
+ *   return word;
+ * }
+ * ```
+ *
+ * @see {@link EnglishInflectionRules} Constant that implements this interface
+ * @see {@link plural} Function that uses these categories for pluralization
+ * @see {@link singular} Function that uses these categories for singularization
+ */
+export interface InflectionRuleCategories {
+    /**
+     * Words that are the same in singular and plural form
+     */
+    INVARIANT: InflectionRule[];
+    /**
+     * Words with irregular plural forms
+     */
+    IRREGULAR: PluralSingularRulePair;
+    /**
+     * Words borrowed from Latin and Greek
+     */
+    LATIN_GREEK: PluralSingularRulePair;
+    /**
+     * Words with specific ending patterns
+     */
+    PATTERN_RULES: PluralSingularRulePair;
+    /**
+     * Default rules for standard transformations
+     */
+    DEFAULT: PluralSingularRulePair;
+}

package/interfaces/inflection-rule.interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=inflection-rule.interfaces.js.map

package/interfaces/inflection-rule.interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflection-rule.interfaces.js","sourceRoot":"","sources":["../../../../libs/utils/src/interfaces/inflection-rule.interfaces.ts"],"names":[],"mappings":""}

package/interfaces/path-value-set.interface.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Represents a flattened object where keys are dot-notation paths and values are primitive types.
+ *
+ * This interface defines a data structure that transforms nested objects into a flat, key-value
+ * dictionary where:
+ * - 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
+ * easier to store, transmit, or manipulate in certain contexts (like databases, query params,
+ * or form handling).
+ *
+ * @remarks
+ * The PathValueSet 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
+ * - **Serializability**: Flattened structure is more amenable to certain serialization formats
+ * - **Transformability**: Easier to apply transformations to all values regardless of nesting level
+ *
+ * Common use cases include:
+ * - Flattening complex objects for storage in key-value databases
+ * - Representing form data with nested field structures
+ * - Simplifying diff operations between complex objects
+ * - 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
+ *
+ * @example
+ * ```typescript
+ * // A PathValueSet representing a nested user object
+ * const userPathValues: PathValueSet = {
+ *   'id': 123,
+ *   'name': 'John Doe',
+ *   'isActive': true,
+ *   'profile.age': 30,
+ *   'profile.address.city': 'New York',
+ *   'profile.address.zip': '10001'
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Converting between nested objects and PathValueSet
+ * import { objectToPathValueSet, pathValueSetToObject } from './object.utils';
+ *
+ * const user = {
+ *   id: 123,
+ *   name: 'John Doe',
+ *   profile: {
+ *     age: 30,
+ *     address: {
+ *       city: 'New York',
+ *       zip: '10001'
+ *     }
+ *   }
+ * };
+ *
+ * // Convert to PathValueSet
+ * const pathValues = objectToPathValueSet(user);
+ *
+ * // Convert back to nested object
+ * const reconstructedUser = pathValueSetToObject(pathValues);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Directly accessing a deeply nested value
+ * const cityValue = userPathValues['profile.address.city']; // 'New York'
+ *
+ * // Updating a specific nested value without touching the rest
+ * userPathValues['profile.address.city'] = 'Boston';
+ * ```
+ */
+export interface PathValueSet {
+    [path: string]: string | number | boolean;
+}

package/interfaces/path-value-set.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=path-value-set.interface.js.map

package/interfaces/path-value-set.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-value-set.interface.js","sourceRoot":"","sources":["../../../../libs/utils/src/interfaces/path-value-set.interface.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hichchi/utils",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-beta.1",
   "publishConfig": {
     "access": "public"
   },
@@ -11,12 +11,12 @@
   "keywords": [],
   "author": "Waruna Udayanga",
   "license": "MIT",
-  "main": "./src/index.ts",
-  "typings": "./src/index.d.ts",
+  "main": "./index.js",
+  "typings": "./index.d.ts",
   "sideEffects": false,
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "types": "./src/index.d.ts",
+  "types": "./index.d.ts",
   "type": "commonjs"
 }

package/readme-top.md

@@ -1,11 +1,187 @@
-# utils
+<!--suppress ALL -->
+<div align="center">
 
-This library was generated with [Nx](https://nx.dev).
+# 🛠️ @hichchi/utils
 
-## Building
+**A comprehensive utility library with essential helper functions for JavaScript/TypeScript applications**
 
-Run `nx build utils` to build the library.
+[![npm version](https://img.shields.io/npm/v/@hichchi/utils?style=flat&color=blue)](https://www.npmjs.com/package/@hichchi/utils)
+[![npm downloads](https://img.shields.io/npm/dm/@hichchi/utils?style=flat&color=green)](https://www.npmjs.com/package/@hichchi/utils)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/hichchidev/hichchi/blob/main/LICENSE)
+[![TypeScript](https://img.shields.io/badge/typescript-5.0+-blue.svg)](https://www.typescriptlang.org/)
 
-## Running unit tests
+*Part of the [Hichchi](https://github.com/hichchidev/hichchi) ecosystem - A powerful, scalable application built with Nx workspace*
 
-Run `nx test utils` to execute the unit tests via [Jest](https://jestjs.io).
+[📚 Jump to Documentation](#-api-documentation)
+
+</div>
+
+---
+
+## 📋 Table Of Contents
+
+- [📦 Installation](#-installation)
+- [⚡ Quick Start](#-quick-start)
+- [📋 Prerequisites](#-prerequisites)
+- [🌟 Overview](#-overview)
+- [✨ Features](#-features)
+- [🛠️ Troubleshooting](#️-troubleshooting)
+- [🔧 Development](#-development)
+- [📖 API Documentation](#-api-documentation)
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @hichchi/utils
+```
+
+## ⚡ Quick Start
+
+Get up and running with powerful utility functions in just a few minutes:
+
+```typescript
+// 1. Install the package
+npm install @hichchi/utils
+
+// 2. Import utility functions
+import { pathValueSetToObject } from '@hichchi/utils';
+
+// 3. Use utility functions in your application
+const nestedObject = pathValueSetToObject({
+    "id": 123,
+    "name": "John Doe",
+    "profile.age": 30,
+    "profile.address.city": "New York",
+    "profile.address.zip": "10001"
+});
+
+Result:
+// {
+//   id: 123,
+//   name: "John Doe",
+//   profile: {
+//     age: 30,
+//     address: {
+//       city: "New York",
+//       zip: "10001"
+//     }
+//   }
+// }
+
+```
+
+## 📋 Prerequisites
+
+Before installing @hichchi/utils, ensure you have:
+
+### Required Dependencies
+- **Node.js**: >= 18.0.0
+- **TypeScript**: >= 5.0.0 (for TypeScript projects)
+
+
+## 🌟 Overview
+
+🎯 **Your essential toolkit** for JavaScript and TypeScript development. From string manipulation to file operations, from object utilities to URL handling - everything you need to streamline your development workflow with battle-tested, performance-optimized utility functions.
+
+## ✨ Features
+
+### 🔤 String Utilities
+- 🎨 **Case Conversion** - camelCase, PascalCase, snake_case, kebab-case transformations
+- 🔍 **String Analysis** - Pattern matching, validation, and content analysis
+- ✂️ **String Manipulation** - Truncation, padding, cleaning, and formatting
+- 🏷️ **Slug Generation** - URL-friendly string generation with customizable options
+- 📝 **Template Processing** - Advanced string templating with variable substitution
+
+### 🗂️ Object Utilities
+- 🔄 **Deep Operations** - Deep merge, clone, compare, and transformation
+- 🎯 **Property Access** - Safe property getting/setting with dot notation
+- 🔍 **Object Analysis** - Type checking, validation, and structure analysis
+- 📊 **Data Transformation** - Object flattening, nesting, and restructuring
+- 🧹 **Object Cleaning** - Remove null/undefined values, empty objects
+
+### 📝 String Template Utilities
+- 🎨 **Template Processing** - Advanced string templating with variable substitution
+- 🔄 **Dynamic Content** - Apply templates with custom prefixes and transformations
+- 🏷️ **Tag-based Processing** - Support for various template tags and formats
+
+### 🌐 URL Utilities
+- 🔒 **Redirect Validation** - Secure redirect URL validation against allowed domains
+- 🛡️ **Security Features** - Prevent open redirect vulnerabilities
+
+### ✅ Assertion Utilities
+- 🔍 **Type Guards** - TypeScript type guards for arrays and objects
+- 🎯 **Property Checking** - Check if objects have specific properties
+- 🛡️ **Safe Type Narrowing** - Runtime type validation with TypeScript support
+
+### 🎨 Developer Experience
+- 📝 **Full TypeScript Support** - Complete type definitions and IntelliSense
+- 🔧 **Tree Shaking** - Import only what you need for optimal bundle size
+- 📚 **Comprehensive Documentation** - Detailed JSDoc comments for all functions
+- 🧪 **Well Tested** - Extensive test coverage for reliability
+- 🚀 **Performance Optimized** - Efficient algorithms and minimal overhead
+
+## 🔒 Security Best Practices
+
+Detailed security best practices will be added here
+
+## 🛠️ Troubleshooting
+
+### Common Issues
+
+#### TypeScript Compilation Issues
+```bash
+# Ensure you have the correct TypeScript version
+npm install typescript@^5.0.0 --save-dev
+```
+
+## 🔧 Development
+
+### Building the Library
+```bash
+nx build utils
+```
+
+### Running Tests
+```bash
+nx test utils
+```
+
+### Linting
+```bash
+nx lint utils
+```
+
+### Performance Testing
+```bash
+nx run utils:benchmark
+```
+
+---
+
+<div align="center">
+
+**Made with ❤️ by [Hichchi Dev](https://github.com/hichchidev)**
+
+[![Hichchi Ecosystem](https://img.shields.io/badge/🏠_Hichchi_Ecosystem-blue)](https://github.com/hichchidev/hichchi)
+[![Report Bug](https://img.shields.io/badge/🐛_Report_Bug-red)](https://github.com/hichchidev/hichchi/issues)
+[![Request Feature](https://img.shields.io/badge/✨_Request_Feature-green)](https://github.com/hichchidev/hichchi/issues)
+
+*Building the future of development utilities, one commit at a time*
+
+</div>
+
+---
+
+# 📖 API Documentation
+
+Complete technical reference for all classes, interfaces, methods, and types in this library.
+
+**Auto-generated by TypeDoc** - Browse through detailed API references, code examples, and implementation guides below.
+
+<!-- TypeDoc generated documentation will be appended below this point -->
+
+---
+
+## 📋 API Table of Contents

package/types/deep-partial.type.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A utility type that recursively makes all properties of an object optional.
+ *
+ * Unlike TypeScript's built-in `Partial<T>` type which only makes top-level properties
+ * optional, `DeepPartial<T>` recursively applies the transformation to nested objects,
+ * arrays, maps, and sets. This makes it ideal for working with complex nested data
+ * structures where you only want to provide a subset of the data.
+ *
+ * Features:
+ * - Makes all object properties optional at every level of nesting
+ * - Handles arrays by making each element a deep partial
+ * - Supports Map objects by making both keys and values deep partials
+ * - Supports Set objects by making each member a deep partial
+ * - Preserves primitive values unchanged
+ *
+ * Common use cases:
+ * - Creating update DTOs where only changed fields need to be provided
+ * - Building test fixtures with minimal required properties
+ * - Implementing patch operations for REST APIs
+ * - Constructing partial configuration objects
+ *
+ * @template T The type to transform into a deep partial
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   id: string;
+ *   name: string;
+ *   profile: {
+ *     avatar: string;
+ *     preferences: {
+ *       theme: string;
+ *       notifications: boolean;
+ *     };
+ *   };
+ *   roles: string[];
+ * }
+ *
+ * // All these are valid DeepPartial<User>
+ * const update1: DeepPartial<User> = { name: 'New Name' };
+ * const update2: DeepPartial<User> = { profile: { preferences: { theme: 'dark' } } };
+ * const update3: DeepPartial<User> = { roles: ['admin'] };
+ * ```
+ */
+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);

package/types/deep-partial.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=deep-partial.type.js.map

package/types/deep-partial.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-partial.type.js","sourceRoot":"","sources":["../../../../libs/utils/src/types/deep-partial.type.ts"],"names":[],"mappings":""}

package/types/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Utility types for TypeScript development
+ *
+ * This module exports a collection of utility types that enhance TypeScript's
+ * type system with additional functionality. These types help with common
+ * type manipulation tasks and provide solutions for advanced typing scenarios.
+ *
+ * Key categories of types included:
+ * - Object type utilities (DeepPartial, PartialWithNull, LiteralObject)
+ * - Type predicates (IsEmpty, IsPrimitive, IsAlreadyInPath)
+ * - Type transformation utilities (Prettify, LooseAutocomplete)
+ * - Constructor and class utilities (Type)
+ *
+ * Import these types individually or from this barrel file to enhance
+ * your TypeScript code with more expressive and precise type definitions.
+ *
+ * @example
+ * ```typescript
+ * // Import all types
+ * import * as Types from '@hichchi/utils/types';
+ *
+ * // Or import specific types
+ * import { DeepPartial, LiteralObject } from '@hichchi/utils/types';
+ * ```
+ */
+export * from "./type.type";
+export * from "./is-empty.type";
+export * from "./prettify.type";
+export * from "./deep-partial.type";
+export * from "./is-primitive.type";
+export * from "./literal-object.type";
+export * from "./partial-with-null.type";
+export * from "./is-already-in-path.type";
+export * from "./loose-autocomplete.type";

package/types/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * Utility types for TypeScript development
+ *
+ * This module exports a collection of utility types that enhance TypeScript's
+ * type system with additional functionality. These types help with common
+ * type manipulation tasks and provide solutions for advanced typing scenarios.
+ *
+ * Key categories of types included:
+ * - Object type utilities (DeepPartial, PartialWithNull, LiteralObject)
+ * - Type predicates (IsEmpty, IsPrimitive, IsAlreadyInPath)
+ * - Type transformation utilities (Prettify, LooseAutocomplete)
+ * - Constructor and class utilities (Type)
+ *
+ * Import these types individually or from this barrel file to enhance
+ * your TypeScript code with more expressive and precise type definitions.
+ *
+ * @example
+ * ```typescript
+ * // Import all types
+ * import * as Types from '@hichchi/utils/types';
+ *
+ * // Or import specific types
+ * import { DeepPartial, LiteralObject } from '@hichchi/utils/types';
+ * ```
+ */
+tslib_1.__exportStar(require("./type.type"), exports);
+tslib_1.__exportStar(require("./is-empty.type"), exports);
+tslib_1.__exportStar(require("./prettify.type"), exports);
+tslib_1.__exportStar(require("./deep-partial.type"), exports);
+tslib_1.__exportStar(require("./is-primitive.type"), exports);
+tslib_1.__exportStar(require("./literal-object.type"), exports);
+tslib_1.__exportStar(require("./partial-with-null.type"), exports);
+tslib_1.__exportStar(require("./is-already-in-path.type"), exports);
+tslib_1.__exportStar(require("./loose-autocomplete.type"), exports);
+//# sourceMappingURL=index.js.map

package/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/utils/src/types/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sDAA4B;AAC5B,0DAAgC;AAChC,0DAAgC;AAChC,8DAAoC;AACpC,8DAAoC;AACpC,gEAAsC;AACtC,mEAAyC;AACzC,oEAA0C;AAC1C,oEAA0C"}

package/types/is-already-in-path.type.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Type predicate that detects circular references in type paths.
+ *
+ * The `IsAlreadyInPath` type evaluates to `true` if type T is already part of the path U,
+ * indicating a potential circular reference. It returns `false` otherwise.
+ *
+ * This utility type is crucial for preventing infinite recursion in recursive type
+ * definitions, particularly when working with deeply nested structures or graphs.
+ *
+ * @template T The type to check if it's in the path
+ * @template U The current path of types
+ *
+ * @example
+ * ```typescript
+ * // Example usage in a recursive type definition
+ * type RecursivelyProcess<T, Path = never> =
+ *   IsAlreadyInPath<T, Path> extends true
+ *     ? any  // Break recursion to prevent infinite type expansion
+ *     : T extends object
+ *       ? { [K in keyof T]: RecursivelyProcess<T[K], Path | T> }
+ *       : T;
+ * ```
+ */
+export type IsAlreadyInPath<T, U> = U extends object ? (T extends U ? true : false) : false;

package/types/is-already-in-path.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is-already-in-path.type.js.map

package/types/is-already-in-path.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-already-in-path.type.js","sourceRoot":"","sources":["../../../../libs/utils/src/types/is-already-in-path.type.ts"],"names":[],"mappings":""}

package/types/is-empty.type.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type predicate that determines if a type is an empty object type.
+ *
+ * The `IsEmpty` type evaluates to `true` if the provided type T has no properties
+ * (i.e., it is an empty object type), and `false` otherwise. This is determined by
+ * checking if `keyof T extends never`.
+ *
+ * This utility type is useful for conditional types that need special handling
+ * for empty objects versus objects with properties.
+ *
+ * @template T The type to check
+ *
+ * @example
+ * ```typescript
+ * // Example with conditional types
+ * type ProcessObject<T> = IsEmpty<T> extends true
+ *   ? { defaultProp: string }  // Provide default for empty objects
+ *   : T;  // Keep non-empty objects as-is
+ *
+ * // Usage
+ * type ProcessedEmpty = ProcessObject<{}>;  // { defaultProp: string }
+ * type ProcessedNonEmpty = ProcessObject<{ name: string }>;  // { name: string }
+ * ```
+ */
+export type IsEmpty<T> = keyof T extends never ? true : false;

package/types/is-empty.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=is-empty.type.js.map

package/types/is-empty.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty.type.js","sourceRoot":"","sources":["../../../../libs/utils/src/types/is-empty.type.ts"],"names":[],"mappings":""}