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

package/constants/english-inflection-rules.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnglishInflectionRules = void 0;
+const constants_1 = require("./constants");
+/**
+ * Comprehensive rules for English word inflection (singular/plural transformations)
+ *
+ * This module provides a structured collection of rules for transforming English words
+ * between singular and plural forms. The rules are organized into categories based on
+ * linguistic patterns and exceptions, ensuring accurate transformations for various
+ * word types.
+ *
+ * Key features:
+ * - Invariant words that are identical in singular and plural forms
+ * - Irregular plural forms that don't follow standard patterns
+ * - Latin and Greek origin words with their specific plural formations
+ * - Pattern-based rules for common English word endings
+ * - Default fallback rules for standard English pluralization
+ *
+ * The rules are applied in a specific priority order, from most specific to most general,
+ * to ensure correct handling of special cases. Each rule consists of a regular expression
+ * pattern and a replacement string or function.
+ *
+ * @example
+ * ```typescript
+ * // Using the rules with the plural() function
+ * import { EnglishInflectionRules } from '@hichchi/utils/constants';
+ * import { InflectionRule } from '@hichchi/utils/interfaces';
+ *
+ * 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 plural} Function that uses these rules to convert words to plural form
+ * @see {@link singular} Function that uses these rules to convert words to singular form
+ * @see {@link InflectionRuleCategories} Interface defining the structure of the rules
+ * @see {@link InflectionRule} Interface for individual transformation rules
+ */
+exports.EnglishInflectionRules = {
+    /**
+     * Words that are the same in singular and plural form
+     *
+     * This category contains rules for words that don't change between singular and plural forms.
+     * These invariant words (also called "zero plurals") have identical singular and plural forms
+     * in English. The rule simply returns the word unchanged.
+     *
+     * Common examples include:
+     * - Animal names: "fish", "deer", "sheep"
+     * - Scientific terms: "species", "series"
+     * - Uncountable nouns: "equipment"
+     *
+     * @example
+     * ```typescript
+     * // These words remain unchanged in plural form
+     * plural("fish");     // "fish"
+     * plural("deer");     // "deer"
+     * plural("sheep");    // "sheep"
+     * plural("species");  // "species"
+     * plural("equipment"); // "equipment"
+     * ```
+     *
+     * @see {@link plural} Function that applies these rules
+     * @see {@link singular} Function that applies these rules
+     */
+    INVARIANT: [{ regex: /^(fish|deer|sheep|species|series|equipment)$/i, replacement: "$1" }],
+    /**
+     * Irregular plural forms
+     *
+     * This category contains rules for words with irregular plural forms that don't
+     * follow standard English pluralization patterns. These words have unique
+     * transformations between singular and plural forms that must be handled as
+     * special cases.
+     *
+     * The category is divided into two rule sets:
+     * - toPlural: Rules for converting singular forms to their irregular plural forms
+     * - toSingular: Rules for converting irregular plural forms back to singular
+     *
+     * These rules handle common irregular English plurals like "child/children",
+     * "man/men", "tooth/teeth", etc. Many of these irregular forms have historical
+     * origins in Old English and other Germanic languages.
+     *
+     * @example
+     * ```typescript
+     * // Singular to plural transformations
+     * plural("child");   // "children"
+     * plural("man");     // "men"
+     * plural("tooth");   // "teeth"
+     * plural("person");  // "people"
+     *
+     * // Plural to singular transformations
+     * singular("children"); // "child"
+     * singular("men");      // "man"
+     * singular("teeth");    // "tooth"
+     * singular("people");   // "person"
+     * ```
+     *
+     * @see {@link plural} Function that applies these rules for pluralization
+     * @see {@link singular} Function that applies these rules for singularization
+     */
+    IRREGULAR: {
+        // Singular to plural transformations
+        toPlural: [
+            { regex: /^child$/i, replacement: "children" },
+            { regex: /^man$/i, replacement: "men" },
+            { regex: /^woman$/i, replacement: "women" },
+            { regex: /^tooth$/i, replacement: "teeth" },
+            { regex: /^foot$/i, replacement: "feet" },
+            { regex: /^goose$/i, replacement: "geese" },
+            { regex: /^mouse$/i, replacement: "mice" },
+            { regex: /^person$/i, replacement: "people" },
+            { regex: /^ox$/i, replacement: "oxen" },
+        ],
+        // Plural to singular transformations
+        toSingular: [
+            { regex: /children$/i, replacement: "child" },
+            { regex: /men$/i, replacement: "man" },
+            { regex: /women$/i, replacement: "woman" },
+            { regex: /teeth$/i, replacement: "tooth" },
+            { regex: /feet$/i, replacement: "foot" },
+            { regex: /geese$/i, replacement: "goose" },
+            { regex: /mice$/i, replacement: "mouse" },
+            { regex: /people$/i, replacement: "person" },
+            { regex: /oxen$/i, replacement: "ox" },
+        ],
+    },
+    /**
+     * Latin/Greek origin words
+     *
+     * This category contains rules for words borrowed from Latin and Greek that
+     * retain their original pluralization patterns. These words follow different
+     * rules than native English words and often have distinctive ending changes.
+     *
+     * The category is divided into two rule sets:
+     * - toPlural: Rules for converting Latin/Greek singular forms to their plural forms
+     * - toSingular: Rules for converting Latin/Greek plural forms back to singular
+     *
+     * Common patterns include:
+     * - "-us" → "-i" (cactus/cacti, fungus/fungi)
+     * - "-is" → "-es" (analysis/analyses, thesis/theses)
+     * - "-on"/"-um" → "-a" (criterion/criteria, datum/data)
+     * - "-ex"/"-ix" → "-ices" (index/indices, matrix/matrices)
+     *
+     * These words are often found in academic, scientific, and technical contexts.
+     * Note that some of these words have alternative anglicized plural forms that
+     * are also acceptable in modern English (e.g., "cactuses" alongside "cacti").
+     *
+     * @example
+     * ```typescript
+     * // Singular to plural transformations
+     * plural("cactus");    // "cacti"
+     * plural("analysis");  // "analyses"
+     * plural("criterion"); // "criteria"
+     * plural("index");     // "indices"
+     * plural("matrix");    // "matrices"
+     *
+     * // Plural to singular transformations
+     * singular("cacti");     // "cactus"
+     * singular("analyses");  // "analysis"
+     * singular("criteria");  // "criterion"
+     * singular("indices");   // "index"
+     * singular("matrices");  // "matrix"
+     * ```
+     *
+     * @see {@link plural} Function that applies these rules for pluralization
+     * @see {@link singular} Function that applies these rules for singularization
+     */
+    LATIN_GREEK: {
+        // Singular to plural transformations
+        toPlural: [
+            { regex: /^cactus$/i, replacement: "cacti" },
+            { regex: /^focus$/i, replacement: "foci" },
+            { regex: /^fungus$/i, replacement: "fungi" },
+            { regex: /^nucleus$/i, replacement: "nuclei" },
+            { regex: /^syllabus$/i, replacement: "syllabi" },
+            { regex: /^analysis$/i, replacement: "analyses" },
+            { regex: /^diagnosis$/i, replacement: "diagnoses" },
+            { regex: /^thesis$/i, replacement: "theses" },
+            { regex: /^criterion$/i, replacement: "criteria" },
+            { regex: /^datum$/i, replacement: "data" },
+            { regex: /^phenomenon$/i, replacement: "phenomena" },
+            { regex: /^index$/i, replacement: "indices" },
+            { regex: /^matrix$/i, replacement: "matrices" },
+            { regex: /^vertex$/i, replacement: "vertices" },
+            { regex: /^appendix$/i, replacement: "appendices" },
+        ],
+        // Plural to singular transformations
+        toSingular: [
+            { regex: /matrices$/i, replacement: "matrix" },
+            { regex: /indices$/i, replacement: "index" },
+            { regex: /vertices$/i, replacement: "vertex" },
+            { regex: /appendices$/i, replacement: "appendix" },
+            { regex: /cacti$/i, replacement: "cactus" },
+            { regex: /foci$/i, replacement: "focus" },
+            { regex: /fungi$/i, replacement: "fungus" },
+            { regex: /nuclei$/i, replacement: "nucleus" },
+            { regex: /syllabi$/i, replacement: "syllabus" },
+            { regex: /analyses$/i, replacement: "analysis" },
+            { regex: /diagnoses$/i, replacement: "diagnosis" },
+            { regex: /theses$/i, replacement: "thesis" },
+            { regex: /criteria$/i, replacement: "criterion" },
+            { regex: /data$/i, replacement: "datum" },
+            { regex: /phenomena$/i, replacement: "phenomenon" },
+        ],
+    },
+    /**
+     * Words with specific ending patterns
+     *
+     * This category contains rules for words that follow regular patterns based on
+     * their endings. These patterns represent the most common rules for English
+     * pluralization and singularization, covering a wide range of everyday words.
+     *
+     * The category is divided into two rule sets:
+     * - toPlural: Rules for converting singular forms to plural based on word endings
+     * - toSingular: Rules for converting plural forms back to singular
+     *
+     * Key pattern groups include:
+     *
+     * 1. Words ending in -f or -fe:
+     *    - "knife" → "knives", "life" → "lives", "wolf" → "wolves"
+     *
+     * 2. Words ending in -y:
+     *    - After consonant: "city" → "cities", "baby" → "babies"
+     *    - After vowel: "boy" → "boys", "key" → "keys"
+     *
+     * 3. Words ending in -o:
+     *    - Some specific words: "hero" → "heroes", "potato" → "potatoes"
+     *    - After consonant: "echo" → "echoes", "tomato" → "tomatoes"
+     *
+     * 4. Words ending in -s, -ss, -sh, -ch, -x, -z:
+     *    - "bus" → "buses", "box" → "boxes", "dish" → "dishes"
+     *
+     * These patterns cover the majority of regular English pluralization rules
+     * and are applied after checking for invariant words, irregular forms, and
+     * Latin/Greek words.
+     *
+     * @example
+     * ```typescript
+     * // Words ending in -f or -fe
+     * plural("knife");   // "knives"
+     * plural("life");    // "lives"
+     * plural("wolf");    // "wolves"
+     *
+     * // Words ending in -y
+     * plural("city");    // "cities"
+     * plural("boy");     // "boys"
+     *
+     * // Words ending in -o
+     * plural("hero");    // "heroes"
+     * plural("photo");   // "photos"
+     *
+     * // Words ending in -s, -ss, -sh, -ch, -x, -z
+     * plural("bus");     // "buses"
+     * plural("box");     // "boxes"
+     * plural("dish");    // "dishes"
+     *
+     * // Plural to singular
+     * singular("knives");  // "knife"
+     * singular("cities");  // "city"
+     * singular("boxes");   // "box"
+     * ```
+     *
+     * @see {@link plural} Function that applies these rules for pluralization
+     * @see {@link singular} Function that applies these rules for singularization
+     * @see {@link CHARACTERS_TO_REMOVE} Constant used in some replacement functions
+     */
+    PATTERN_RULES: {
+        // Singular to plural transformations
+        toPlural: [
+            // Words ending in -f or -fe
+            { regex: /^((?:wi|li)fe)$/i, replacement: "$1ves" },
+            { regex: /(fe)$/i, replacement: "ves" },
+            { regex: /([^f])f$/i, replacement: "$1ves" },
+            // Words ending in -y
+            { regex: /([^aeiou])y$/i, replacement: "$1ies" },
+            { regex: /([aeiou]y)$/i, replacement: "$1s" },
+            // Words ending in -o
+            { regex: /(hero|potato|tomato|torpedo|veto)$/i, replacement: "$1es" },
+            { regex: /([^aeiou])o$/i, replacement: "$1oes" },
+            // Words ending in -is
+            { regex: /(is)$/i, replacement: "es" },
+            // Words ending in -us
+            { regex: /(us)$/i, replacement: "uses" },
+            // Words ending in -s, -ss, -sh, -ch, -x, -z
+            { regex: /(s|ss|sh|ch|x|z)$/i, replacement: "$1es" },
+        ],
+        // Plural to singular transformations
+        toSingular: [
+            // Special spelling changes
+            { regex: /knives$/i, replacement: "knife" },
+            { regex: /lives$/i, replacement: "life" },
+            { regex: /shelves$/i, replacement: "shelf" },
+            // Common word patterns
+            {
+                regex: /(buses|dishes|matches)$/i,
+                replacement: (match) => match.slice(0, -constants_1.CHARACTERS_TO_REMOVE),
+            },
+            { regex: /([^aeiouy]|qu)ies$/i, replacement: "$1y" },
+            { regex: /(x|ch|ss|sh)es$/i, replacement: "$1" },
+            { regex: /oes$/i, replacement: "o" },
+            { regex: /ves$/i, replacement: "f" },
+        ],
+    },
+    /**
+     * Default rules for standard transformations
+     *
+     * This category contains fallback rules that are applied when no other rules match.
+     * These represent the most basic and common English pluralization pattern: adding
+     * an "s" to form plurals and removing an "s" to form singulars.
+     *
+     * The category is divided into two rule sets:
+     * - toPlural: Adds "s" to the end of any word to form its plural
+     * - toSingular: Removes a trailing "s" from any word to form its singular
+     *
+     * These rules are applied as a last resort after all other more specific rules
+     * have been checked. They handle the majority of regular English words that don't
+     * fall into any of the special categories or patterns.
+     *
+     * While simple, these rules can sometimes produce incorrect results for words that
+     * should follow more specific patterns but weren't included in the other rule sets.
+     * They're designed as a reasonable fallback rather than a comprehensive solution.
+     *
+     * @example
+     * ```typescript
+     * // Singular to plural with default rule
+     * plural("book");    // "books"
+     * plural("car");     // "cars"
+     * plural("apple");   // "apples"
+     *
+     * // Plural to singular with default rule
+     * singular("books");  // "book"
+     * singular("cars");   // "car"
+     * singular("apples"); // "apple"
+     * ```
+     *
+     * @see {@link plural} Function that applies these rules for pluralization
+     * @see {@link singular} Function that applies these rules for singularization
+     */
+    DEFAULT: {
+        toPlural: [{ regex: /(.*)$/i, replacement: "$1s" }],
+        toSingular: [{ regex: /s$/i, replacement: "" }],
+    },
+};
+//# sourceMappingURL=english-inflection-rules.js.map

package/constants/english-inflection-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"english-inflection-rules.js","sourceRoot":"","sources":["../../../../libs/utils/src/constants/english-inflection-rules.ts"],"names":[],"mappings":"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"}

package/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./constants";
+export * from "./english-inflection-rules";

package/constants/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./english-inflection-rules"), exports);
+//# sourceMappingURL=index.js.map

package/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/utils/src/constants/index.ts"],"names":[],"mappings":";;;AAAA,sDAA4B;AAC5B,qEAA2C"}

package/enums/index.d.ts

@@ -0,0 +1 @@
+export * from "./template-tag.enum";

package/{src → enums}/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib"), exports);
+tslib_1.__exportStar(require("./template-tag.enum"), exports);
 //# sourceMappingURL=index.js.map

package/enums/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/utils/src/enums/index.ts"],"names":[],"mappings":";;;AAAA,8DAAoC"}

package/enums/template-tag.enum.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Template tags for string transformations
+ *
+ * This enum defines all available template tags that can be used with the `applyTemplate`
+ * and `applyTemplates` functions. Each tag corresponds to a specific string transformation
+ * function from the string.utils module.
+ *
+ * Template tags are represented as strings in the format `#{transformationName}`. When these
+ * tags appear in template strings, they are replaced with the result of applying the
+ * corresponding transformation to the provided value.
+ *
+ * @see {@link applyTemplate} For applying a single value to a template
+ * @see {@link applyTemplates} For applying multiple values to a template
+ */
+export declare enum TemplateTag {
+    UPPER_CASE = "#{upperCase}",
+    SNAKE_CASE = "#{snakeCase}",
+    UPPER_SNAKE_CASE = "#{upperSnakeCase}",
+    LOWER_CASE = "#{lowerCase}",
+    SENTENCE_CASE = "#{sentenceCase}",
+    FIRST_CASE = "#{firstCase}",
+    CAMEL_CASE = "#{camelCase}",
+    PASCAL_CASE = "#{pascalCase}",
+    KEBAB_CASE = "#{kebabCase}",
+    UPPER_KEBAB_CASE = "#{upperKebabCase}",
+    TITLE_CASE = "#{titleCase}",
+    LOWER_CASE_BREAK = "#{lowerCaseBreak}",
+    UPPER_CASE_BREAK = "#{upperCaseBreak}",
+    FIRST_CASE_BREAK = "#{firstCaseBreak}",
+    SINGULAR = "#{singular}",
+    NUMBER = "#{number}",
+    HTML_TO_TEXT = "#{htmlToText}"
+}

package/enums/template-tag.enum.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateTag = void 0;
+/**
+ * Template tags for string transformations
+ *
+ * This enum defines all available template tags that can be used with the `applyTemplate`
+ * and `applyTemplates` functions. Each tag corresponds to a specific string transformation
+ * function from the string.utils module.
+ *
+ * Template tags are represented as strings in the format `#{transformationName}`. When these
+ * tags appear in template strings, they are replaced with the result of applying the
+ * corresponding transformation to the provided value.
+ *
+ * @see {@link applyTemplate} For applying a single value to a template
+ * @see {@link applyTemplates} For applying multiple values to a template
+ */
+var TemplateTag;
+(function (TemplateTag) {
+    TemplateTag["UPPER_CASE"] = "#{upperCase}";
+    TemplateTag["SNAKE_CASE"] = "#{snakeCase}";
+    TemplateTag["UPPER_SNAKE_CASE"] = "#{upperSnakeCase}";
+    TemplateTag["LOWER_CASE"] = "#{lowerCase}";
+    TemplateTag["SENTENCE_CASE"] = "#{sentenceCase}";
+    TemplateTag["FIRST_CASE"] = "#{firstCase}";
+    TemplateTag["CAMEL_CASE"] = "#{camelCase}";
+    TemplateTag["PASCAL_CASE"] = "#{pascalCase}";
+    TemplateTag["KEBAB_CASE"] = "#{kebabCase}";
+    TemplateTag["UPPER_KEBAB_CASE"] = "#{upperKebabCase}";
+    TemplateTag["TITLE_CASE"] = "#{titleCase}";
+    TemplateTag["LOWER_CASE_BREAK"] = "#{lowerCaseBreak}";
+    TemplateTag["UPPER_CASE_BREAK"] = "#{upperCaseBreak}";
+    TemplateTag["FIRST_CASE_BREAK"] = "#{firstCaseBreak}";
+    TemplateTag["SINGULAR"] = "#{singular}";
+    TemplateTag["NUMBER"] = "#{number}";
+    TemplateTag["HTML_TO_TEXT"] = "#{htmlToText}";
+    // FORMAT = "#{format}",
+})(TemplateTag || (exports.TemplateTag = TemplateTag = {}));
+//# sourceMappingURL=template-tag.enum.js.map

package/enums/template-tag.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-tag.enum.js","sourceRoot":"","sources":["../../../../libs/utils/src/enums/template-tag.enum.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;GAaG;AACH,IAAY,WAmBX;AAnBD,WAAY,WAAW;IACnB,0CAA2B,CAAA;IAC3B,0CAA2B,CAAA;IAC3B,qDAAsC,CAAA;IACtC,0CAA2B,CAAA;IAC3B,gDAAiC,CAAA;IACjC,0CAA2B,CAAA;IAC3B,0CAA2B,CAAA;IAC3B,4CAA6B,CAAA;IAC7B,0CAA2B,CAAA;IAC3B,qDAAsC,CAAA;IACtC,0CAA2B,CAAA;IAC3B,qDAAsC,CAAA;IACtC,qDAAsC,CAAA;IACtC,qDAAsC,CAAA;IACtC,uCAAwB,CAAA;IACxB,mCAAoB,CAAA;IACpB,6CAA8B,CAAA;IAC9B,wBAAwB;AAC5B,CAAC,EAnBW,WAAW,2BAAX,WAAW,QAmBtB"}

package/index.d.ts

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

package/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./interfaces"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./enums"), exports);
+tslib_1.__exportStar(require("./constants"), exports);
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../libs/utils/src/index.ts"],"names":[],"mappings":";;;AAAA,kDAAwB;AACxB,uDAA6B;AAC7B,kDAAwB;AACxB,kDAAwB;AACxB,sDAA4B"}

package/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./path-value-set.interface";
+export * from "./infinite-object.interface";
+export * from "./inflection-rule.interfaces";

package/interfaces/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./path-value-set.interface"), exports);
+tslib_1.__exportStar(require("./infinite-object.interface"), exports);
+tslib_1.__exportStar(require("./inflection-rule.interfaces"), exports);
+//# sourceMappingURL=index.js.map

package/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/utils/src/interfaces/index.ts"],"names":[],"mappings":";;;AAAA,qEAA2C;AAC3C,sEAA4C;AAC5C,uEAA6C"}

package/interfaces/infinite-object.interface.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Represents an object with infinite nesting capability (recursive object type).
+ *
+ * This interface defines a recursive type that allows for objects with arbitrary depth of nesting,
+ * where each property value can itself be another infinitely-nestable object. This pattern is useful
+ * for representing hierarchical data structures, configuration objects, or any data that requires
+ * unlimited nesting depth.
+ *
+ * The interface uses TypeScript's index signature to allow any string key, with values that
+ * must be of the same InfiniteObject type, creating the recursive structure.
+ *
+ * @remarks
+ * While this interface allows for infinite nesting in theory, practical limitations apply:
+ * - JavaScript engine stack size limits may cause errors with extremely deep nesting
+ * - Performance degrades with very deep object hierarchies
+ * - Serialization/deserialization of deeply nested objects may be problematic
+ *
+ * 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
+ *
+ * @example
+ * ```typescript
+ * // Creating a deeply nested object
+ * const nestedObj: InfiniteObject = {
+ *   level1: {
+ *     level2: {
+ *       level3: {
+ *         property: {
+ *           value: {
+ *             // Can continue nesting indefinitely
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export interface InfiniteObject {
+    [key: string]: InfiniteObject;
+}

package/interfaces/infinite-object.interface.js

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

package/interfaces/infinite-object.interface.js.map

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