TypeScript: Dynamic Set Creation from Nested Objects

This challenge focuses on creating a TypeScript Set dynamically based on a specified "path" within a nested object structure. This is useful for efficiently storing unique values found at specific locations within complex data, enabling quick lookups and deduplication.

Problem Description

Your task is to implement a function createSetByPath in TypeScript. This function will take a nested object and a path (represented as a dot-separated string) as input. It should traverse the object according to the provided path, collect all values found at that path across potentially multiple nested structures, and return them as a Set.

Key Requirements:

1. Path Traversal: The function must correctly navigate through nested objects using the dot-separated path. For example, a path like "a.b.c" should access obj.a.b.c.
2. Array Handling: If any segment of the path points to an array, the traversal should continue for each element within that array.
3. Value Collection: All values found at the end of the specified path should be collected.
4. Set Output: The collected values must be returned as a Set in TypeScript. This automatically handles deduplication.
5. Type Safety: The function should be strongly typed, inferring the type of the values being collected where possible.

Expected Behavior:

• If the path leads to a single value, that value should be added to the set.
• If the path leads to an array of values, each value in the array should be added to the set.
• If the path leads to an array of objects, and the path continues into those objects, the traversal should apply to each object in the array.
• If at any point during traversal a segment of the path is missing (e.g., a key doesn't exist, or an index is out of bounds for an array), that branch of traversal should simply stop and not contribute any values to the set.
• If the initial object is null or undefined, an empty Set should be returned.

Edge Cases to Consider:

• Empty path string ("").
• Path segments that are numbers (representing array indices).
• Path segments that are strings (representing object keys).
• Objects containing null or undefined values along the path.
• Arrays containing null or undefined values.
• Circular references (though for this challenge, we will assume no circular references for simplicity).
• The input object being empty or null/undefined.

Examples

Example 1:

const data1 = {
  users: [
    { id: 1, name: "Alice", profile: { email: "alice@example.com" } },
    { id: 2, name: "Bob", profile: { email: "bob@example.com" } },
    { id: 3, name: "Charlie", profile: null } // Profile is null
  ]
};

const path1 = "users.profile.email";

// Expected Output: Set { "alice@example.com", "bob@example.com" }

Explanation: The path traverses data1.users, which is an array. For each user object in the array, it then accesses profile, and finally email. The null profile for Charlie is skipped.

Example 2:

const data2 = {
  items: [
    { name: "Apple", tags: ["fruit", "sweet"] },
    { name: "Carrot", tags: ["vegetable", "root"] },
    { name: "Banana", tags: ["fruit", "yellow"] }
  ]
};

const path2 = "items.tags";

// Expected Output: Set { "fruit", "sweet", "vegetable", "root", "yellow" }

Explanation: The path items leads to an array of objects. The next segment tags accesses the tags array within each item object. All tags from all items are collected and deduplicated.

Example 3: (Edge case with missing path segments)

const data3 = {
  config: {
    settings: {
      timeout: 5000,
      retries: 3
    }
  },
  defaults: {
    settings: {
      timeout: 3000
    }
  }
};

const path3 = "config.settings.timeout";

// Expected Output: Set { 5000 }

Explanation: The path successfully navigates to data3.config.settings.timeout. The defaults.settings.timeout is not found because the path explicitly starts with config.

Example 4: (Accessing array elements directly)

const data4 = {
  matrix: [
    [1, 2, 3],
    [4, 5, 6]
  ]
};

const path4 = "matrix.0.1"; // Accesses the second element of the first inner array

// Expected Output: Set { 2 }

Explanation: The path first accesses matrix, then the first array (.0), and then the second element within that array (.1).

Example 5: (Empty input object)

const data5 = {};
const path5 = "a.b.c";

// Expected Output: Set {}

Explanation: The input object is empty, so no values can be found along the path.

Constraints

• The input object obj can be arbitrarily nested.
• The path string will consist of valid JavaScript property names or array indices (numbers) separated by dots (.).
• Path segments will not be empty (e.g., "a..b" is not a valid path).
• The function should handle up to 10 levels of nesting for practical purposes.
• The number of elements in any array encountered during traversal will not exceed 1000.
• The total number of values collected before deduplication will not exceed 10,000.

Notes

• Consider how to handle type safety. A generic function would be ideal.
• Think about the base case for your recursive traversal (or iterative approach).
• Pay close attention to how you differentiate between object property access and array element access.
• The use of Set inherently handles deduplication, so focus on correctly collecting all relevant values.
• You might find utility in a helper function to safely get a nested property.