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

package/src/lib/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/src/lib/interfaces/inflection-rule.interfaces.js

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

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

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

package/src/lib/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/src/lib/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/src/lib/interfaces/path-value-set.interface.js.map

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

package/src/lib/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/src/lib/types/deep-partial.type.js

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

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

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

package/src/lib/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/src/lib/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/src/lib/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../libs/utils/src/lib/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/src/lib/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/src/lib/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/src/lib/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/lib/types/is-already-in-path.type.ts"],"names":[],"mappings":""}

package/src/lib/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/src/lib/types/is-empty.type.js

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

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

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

package/src/lib/types/is-primitive.type.d.ts

@@ -0,0 +1,27 @@
+export type Primitive = string | number | boolean | symbol | bigint | null | undefined;
+export type NonNullPrimitive = string | number | boolean | symbol | bigint;
+/**
+ * Type predicate that determines if a type is a primitive JavaScript value.
+ *
+ * The `IsPrimitive` type evaluates to `true` if the provided type T is a primitive
+ * JavaScript value (string, number, boolean, symbol, bigint, null, or undefined),
+ * and `false` otherwise (objects, arrays, functions, etc.).
+ *
+ * This utility type is useful for creating conditional types that need to
+ * behave differently for primitive vs. non-primitive values.
+ *
+ * @template T The type to check
+ *
+ * @example
+ * ```typescript
+ * // Example with conditional types
+ * type SerializeValue<T> = IsPrimitive<T> extends true
+ *   ? T  // For primitives, keep as-is
+ *   : string;  // For non-primitives, convert to string
+ *
+ * // Usage
+ * type SerializedNumber = SerializeValue<number>;  // number
+ * type SerializedObject = SerializeValue<{foo: string}>;  // string
+ * ```
+ */
+export type IsPrimitive<T> = T extends Primitive ? true : false;

package/src/lib/types/is-primitive.type.js

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

package/src/lib/types/is-primitive.type.js.map

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

package/src/lib/types/literal-object.type.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Generic interface for objects with string keys and values of a specified type.
+ *
+ * `LiteralObject` represents a simple key-value dictionary where all keys are strings
+ * and all values are of the same type T. It provides a type-safe way to work with
+ * dynamic objects that have arbitrary string keys.
+ *
+ * Key features:
+ * - Allows any string as a key using an index signature
+ * - Generic type parameter for values with `any` as the default
+ * - Useful for representing dynamic objects with unknown structure
+ * - Commonly used in object transformation and manipulation utilities
+ *
+ * Common use cases:
+ * - Working with JSON data
+ * - Creating dictionaries or maps with string keys
+ * - Representing configuration objects
+ * - Handling data with dynamic property names
+ *
+ * @template T The type of values in the object (defaults to `any`)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with default any type
+ * const config: LiteralObject = {
+ *   apiUrl: 'https://api.example.com',
+ *   timeout: 5000,
+ *   retryCount: 3
+ * };
+ *
+ * // With a specific value type
+ * const stringMap: LiteralObject<string> = {
+ *   en: 'Hello',
+ *   fr: 'Bonjour',
+ *   es: 'Hola'
+ * };
+ *
+ * // Accessing properties dynamically
+ * function getValue(obj: LiteralObject, key: string): any {
+ *   return obj[key];
+ * }
+ * ```
+ *
+ * @see {@link objectToPathValueSet} Utility that uses LiteralObject for object flattening
+ * @see {@link PathValueSet} Related interface for flattened object representation
+ */
+export interface LiteralObject<T = any> {
+    [key: string]: T;
+}

package/src/lib/types/literal-object.type.js

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

package/src/lib/types/literal-object.type.js.map

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

package/src/lib/{types.d.ts → types/loose-autocomplete.type.d.ts}

@@ -1,9 +1,3 @@
-export type LiteralObject<T = any> = {
-    [key: string]: T;
-};
-export type PartialWithNull<T> = {
-    [p in keyof T]?: T[p] | null;
-};
 /**
  * Represents a type for autocompleting string values.
  *
@@ -15,6 +9,24 @@ export type PartialWithNull<T> = {
  *
  * @template T Extends string - The set of predefined literal string options for autocompletion.
  *
+ * @example
+ * ```typescript
+ * // Define a set of color options
+ * type ColorOption = 'red' | 'green' | 'blue';
+ *
+ * // Function that accepts predefined colors but also allows custom colors
+ * function setColor(color: LooseAutocomplete<ColorOption>): void {
+ *   console.log(`Setting color to: ${color}`);
+ * }
+ *
+ * // Usage with predefined options (gets autocomplete)
+ * setColor('red');     // Works, with autocomplete
+ * setColor('green');   // Works, with autocomplete
+ *
+ * // Usage with custom string (allowed, but no autocomplete)
+ * setColor('purple');  // Also works, even though not in predefined options
+ * ```
+ *
  * @author Matt Pocock (https://www.totaltypescript.com/tips/create-autocomplete-helper-which-allows-for-arbitrary-values)
  */
 export type LooseAutocomplete<T extends string> = T | Omit<string, T>;

package/src/lib/types/loose-autocomplete.type.js

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

package/src/lib/types/loose-autocomplete.type.js.map

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

package/src/lib/types/partial-with-null.type.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Makes all properties of type T optional and allows them to be null.
+ *
+ * This type is similar to TypeScript's built-in `Partial<T>` type, but it also
+ * allows properties to be null in addition to being undefined or their original type.
+ *
+ * @template T The type to make partial with null.
+ *
+ * @example
+ * ```TypeScript
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * // All properties are optional and can be null
+ * const partialUser: PartialWithNull<User> = {
+ *   id: 1,
+ *   name: null,
+ *   // email is omitted (undefined)
+ * };
+ * ```
+ */
+export type PartialWithNull<T> = {
+    [p in keyof T]?: T[p] | null;
+};

package/src/lib/types/partial-with-null.type.js

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

package/src/lib/types/partial-with-null.type.js.map

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

package/src/lib/types/prettify.type.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Utility type for creating a clean object type from a complex type.
+ *
+ * The `Prettify` type takes a potentially complex type (with intersections, unions,
+ * mapped types, etc.) and converts it into a simple object type with all properties
+ * explicitly defined. This makes the resulting type easier to read in IDE tooltips
+ * and type errors.
+ *
+ * @template T The complex type to simplify
+ *
+ * @author Matt Pocock (https://www.totaltypescript.com/tips/create-autocomplete-helper-which-allows-for-arbitrary-values)
+ *
+ * @example
+ * ```typescript
+ * // Instead of seeing: { a: number } & { b: string }
+ * // You'll see: { a: number, b: string }
+ * type ComplexType = { a: number } & { b: string };
+ * type SimpleType = Prettify<ComplexType>;
+ * ```
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/src/lib/types/prettify.type.js

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

package/src/lib/types/prettify.type.js.map

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